Skip to contentSkip to conversation

mmc: sdhci-of-dwcmshc: Add runtime PM operations for BlueField-3

PATCH Superseded Liming Sun 4 participants 42 messages May 11, 2023 – Aug 24, 2023

Subsystems (2)
lore
Share & tools
lore

Liming Sun

author
#0 lore raw

PATCH 1/1 mmc: sdhci-of-dwcmshc: Add runtime PM operations for BlueField-3

This commit implements the runtime PM operations for BlueField-3 SoC to disable eMMC card clock when idle.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 76 ++++++++++++++++++++++++++++-
 1 file changed, 74 insertions(+), 2 deletions(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +74 -2
index e68cd87998c8..19ce058fc5f0 100644
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -542,8 +543,10 @@ static int dwcmshc_probe(struct platform_device *pdev)
 	}
 
 #ifdef CONFIG_ACPI
-	if (pltfm_data == &sdhci_dwcmshc_bf3_pdata)
+	if (pltfm_data == &sdhci_dwcmshc_bf3_pdata) {
 		sdhci_enable_v4_mode(host);
+		pm_runtime_enable(dev);
+	}
 #endif
 
 	host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
@@ -646,7 +649,76 @@ static int dwcmshc_resume(struct device *dev)
 }
 #endif
 
-static SIMPLE_DEV_PM_OPS(dwcmshc_pmops, dwcmshc_suspend, dwcmshc_resume);
+#ifdef CONFIG_PM
+
+#ifdef CONFIG_ACPI
+static void dwcmshc_enable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	ctrl |= SDHCI_CLOCK_CARD_EN;
+	sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+}
+
+static void dwcmshc_disable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	ctrl &= ~SDHCI_CLOCK_CARD_EN;
+	sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+}
+#endif
+
+static int dwcmshc_runtime_suspend(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+	const struct sdhci_pltfm_data *pltfm_data;
+	int ret = 0;
+
+	pltfm_data = device_get_match_data(dev);
+	if (!pltfm_data)
+		return -ENODEV;
+
+#ifdef CONFIG_ACPI
+	if (pltfm_data == &sdhci_dwcmshc_bf3_pdata) {
+		ret = sdhci_runtime_suspend_host(host);
+		if (!ret)
+			dwcmshc_disable_card_clk(host);
+	}
+#endif
+
+	return ret;
+}
+
+static int dwcmshc_runtime_resume(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+	const struct sdhci_pltfm_data *pltfm_data;
+	int ret = 0;
+
+	pltfm_data = device_get_match_data(dev);
+	if (!pltfm_data)
+		return -ENODEV;
+
+#ifdef CONFIG_ACPI
+	if (pltfm_data == &sdhci_dwcmshc_bf3_pdata) {
+		dwcmshc_enable_card_clk(host);
+		ret = sdhci_runtime_resume_host(host, 0);
+	}
+#endif
+
+	return ret;
+}
+
+#endif
+
+static const struct dev_pm_ops dwcmshc_pmops = {
+	SET_SYSTEM_SLEEP_PM_OPS(dwcmshc_suspend, dwcmshc_resume)
+	SET_RUNTIME_PM_OPS(dwcmshc_runtime_suspend,
+			   dwcmshc_runtime_resume, NULL)
+};
 
 static struct platform_driver sdhci_dwcmshc_driver = {
 	.driver	= {
Signature · 1 line
2.30.1
#1 lore raw
Quoted 23 lines · Liming Sun

This commit implements the runtime PM operations for BlueField-3 SoC to disable eMMC card clock when idle.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 76 ++++++++++++++++++++++++++++-
 1 file changed, 74 insertions(+), 2 deletions(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +1 -0
index e68cd87998c8..19ce058fc5f0 100644
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_probe(struct platform_device *pdev) · line 548

Quoted 7 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +2 -1
@@ -542,8 +543,10 @@ static int dwcmshc_probe(struct platform_device *pdev)
        }
 
 #ifdef CONFIG_ACPI
-       if (pltfm_data == &sdhci_dwcmshc_bf3_pdata)
+       if (pltfm_data == &sdhci_dwcmshc_bf3_pdata) {
                sdhci_enable_v4_mode(host);
+               pm_runtime_enable(dev);

Why make this ACPI specific? Wouldn't other platforms benefit from this change too?

[...]

Kind regards
Uffe

author
#2 lore raw
Quoted 41 lines

-----Original Message-----
From: Ulf Hansson <[email protected]>
Sent: Friday, May 12, 2023 3:36 AM
To: Liming Sun <[email protected]>
Cc: Adrian Hunter <[email protected]>; David Thompson <[email protected]>; [email protected]; linux- [email protected]
Subject: Re: [PATCH v1 1/1] mmc: sdhci-of-dwcmshc: Add runtime PM operations for BlueField-3

Quoted 8 lines · Liming Sun

This commit implements the runtime PM operations for BlueField-3 SoC to disable eMMC card clock when idle.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 76

++++++++++++++++++++++++++++-

drivers/mmc/host/sdhci-

Quoted 3 lines
 1 file changed, 74 insertions(+), 2 deletions(-)
drivers/mmc/host/sdhci- renamed from drivers/mmc/host/sdhci-of-dwcmshc.c +0 -0

of-dwcmshc.c

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_probe(struct platform_device

Quoted 12 lines

index e68cd87998c8..19ce058fc5f0 100644

drivers/mmc/host/sdhci-of-dwcmshc.c +1 -0
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -542,8 +543,10 @@ static int dwcmshc_probe(struct platform_device

*pdev)

Quoted 2 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +0 -0
        }
 
Quoted 8 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_probe(struct platform_device *pdev) · line 548

Quoted 5 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +2 -1
 #ifdef CONFIG_ACPI
-       if (pltfm_data == &sdhci_dwcmshc_bf3_pdata)
+       if (pltfm_data == &sdhci_dwcmshc_bf3_pdata) {
                sdhci_enable_v4_mode(host);
+               pm_runtime_enable(dev);

Why make this ACPI specific? Wouldn't other platforms benefit from this change too?

Sure, let me post v2 to make it generic for sdhci-of-dwcmshc.

Quoted 5 lines

[...]

Kind regards
Uffe

author
#3 lore raw

PATCH v2 1/1 mmc: sdhci-of-dwcmshc: Add runtime PM operations for BlueField-3

In reply to Liming Sun

This commit implements the runtime PM operations for BlueField-3 SoC to disable eMMC card clock when idle.

---
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 56 ++++++++++++++++++++++++++++-
 1 file changed, 55 insertions(+), 1 deletion(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +55 -1
index e68cd87998c8..a3277f4d250d 100644
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -546,6 +547,8 @@ static int dwcmshc_probe(struct platform_device *pdev)
 		sdhci_enable_v4_mode(host);
 #endif
 
+	pm_runtime_enable(dev);
+
 	host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
 	err = sdhci_setup_host(host);
@@ -646,7 +649,58 @@ static int dwcmshc_resume(struct device *dev)
 }
 #endif
 
-static SIMPLE_DEV_PM_OPS(dwcmshc_pmops, dwcmshc_suspend, dwcmshc_resume);
+#ifdef CONFIG_PM
+
+#ifdef CONFIG_ACPI
+static void dwcmshc_enable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	ctrl |= SDHCI_CLOCK_CARD_EN;
+	sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+}
+
+static void dwcmshc_disable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	ctrl &= ~SDHCI_CLOCK_CARD_EN;
+	sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+}
+#endif
+
+static int dwcmshc_runtime_suspend(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+	int ret = 0;
+
+	ret = sdhci_runtime_suspend_host(host);
+	if (!ret)
+		dwcmshc_disable_card_clk(host);
+
+	return ret;
+}
+
+static int dwcmshc_runtime_resume(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+	int ret = 0;
+
+	dwcmshc_enable_card_clk(host);
+	ret = sdhci_runtime_resume_host(host, 0);
+
+	return ret;
+}
+
+#endif
+
+static const struct dev_pm_ops dwcmshc_pmops = {
+	SET_SYSTEM_SLEEP_PM_OPS(dwcmshc_suspend, dwcmshc_resume)
+	SET_RUNTIME_PM_OPS(dwcmshc_runtime_suspend,
+			   dwcmshc_runtime_resume, NULL)
+};
 
 static struct platform_driver sdhci_dwcmshc_driver = {
 	.driver	= {
Signature · 1 line
2.30.1
author
#4 lore raw

PATCH v3 1/1 mmc: sdhci-of-dwcmshc: Add runtime PM operations

In reply to Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 56 ++++++++++++++++++++++++++++-
 1 file changed, 55 insertions(+), 1 deletion(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +55 -1
index e68cd87998c8..a3277f4d250d 100644
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -546,6 +547,8 @@ static int dwcmshc_probe(struct platform_device *pdev)
 		sdhci_enable_v4_mode(host);
 #endif
 
+	pm_runtime_enable(dev);
+
 	host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
 	err = sdhci_setup_host(host);
@@ -646,7 +649,58 @@ static int dwcmshc_resume(struct device *dev)
 }
 #endif
 
-static SIMPLE_DEV_PM_OPS(dwcmshc_pmops, dwcmshc_suspend, dwcmshc_resume);
+#ifdef CONFIG_PM
+
+#ifdef CONFIG_ACPI
+static void dwcmshc_enable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	ctrl |= SDHCI_CLOCK_CARD_EN;
+	sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+}
+
+static void dwcmshc_disable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	ctrl &= ~SDHCI_CLOCK_CARD_EN;
+	sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+}
+#endif
+
+static int dwcmshc_runtime_suspend(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+	int ret = 0;
+
+	ret = sdhci_runtime_suspend_host(host);
+	if (!ret)
+		dwcmshc_disable_card_clk(host);
+
+	return ret;
+}
+
+static int dwcmshc_runtime_resume(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+	int ret = 0;
+
+	dwcmshc_enable_card_clk(host);
+	ret = sdhci_runtime_resume_host(host, 0);
+
+	return ret;
+}
+
+#endif
+
+static const struct dev_pm_ops dwcmshc_pmops = {
+	SET_SYSTEM_SLEEP_PM_OPS(dwcmshc_suspend, dwcmshc_resume)
+	SET_RUNTIME_PM_OPS(dwcmshc_runtime_suspend,
+			   dwcmshc_runtime_resume, NULL)
+};
 
 static struct platform_driver sdhci_dwcmshc_driver = {
 	.driver	= {
Signature · 1 line
2.30.1
#5 lore raw

Re: [PATCH v3] mmc: sdhci-of-dwcmshc: Add runtime PM operations

kernel test robot noticed the following build errors:

Hi Liming,

kernel test robot noticed the following build errors:

[auto build test ERROR on ulf-hansson-mmc-mirror/next]
[also build test ERROR on linus/master v6.4-rc1 next-20230512] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]

url:    https://github.com/intel-lab-lkp/linux/commits/Liming-Sun/mmc-sdhci-of-dwcmshc-Add-runtime-PM-operations/20230512-202948
base:   https://git.linaro.org/people/ulf.hansson/mmc-mirror.git next
patch link:    https://lore.kernel.org/r/20230512122648.223974-1-limings%40nvidia.com
patch subject: [PATCH v3] mmc: sdhci-of-dwcmshc: Add runtime PM operations
config: arc-allyesconfig (https://download.01.org/0day-ci/archive/20230513/[email protected]/config)
compiler: arceb-elf-gcc (GCC) 12.1.0

reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# https://github.com/intel-lab-lkp/linux/commit/eb5d4c0702ce24630f3d82a37f39437f52607cbb
git remote add linux-review https://github.com/intel-lab-lkp/linux
git fetch --no-tags linux-review Liming-Sun/mmc-sdhci-of-dwcmshc-Add-runtime-PM-operations/20230512-202948 git checkout eb5d4c0702ce24630f3d82a37f39437f52607cbb
# save the config file
mkdir build_dir && cp config build_dir/.config
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-12.1.0 make.cross W=1 O=build_dir ARCH=arc olddefconfig COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-12.1.0 make.cross W=1 O=build_dir ARCH=arc SHELL=/bin/bash

If you fix the issue, kindly add following tag where applicable
| Reported-by: kernel test robot <[email protected]>
| Link: https://lore.kernel.org/oe-kbuild-all/[email protected]/

All errors (new ones prefixed by >>):

drivers/mmc/host/sdhci-of-dwcmshc.c: In function 'dwcmshc_runtime_suspend':

>> drivers/mmc/host/sdhci-of-dwcmshc.c:674:17: error: implicit declaration of function 'dwcmshc_disable_card_clk' [-Werror=implicit-function-declaration]
     674 |                 dwcmshc_disable_card_clk(host);
         |                 ^~~~~~~~~~~~~~~~~~~~~~~~
   drivers/mmc/host/sdhci-of-dwcmshc.c: In function 'dwcmshc_runtime_resume':
>> drivers/mmc/host/sdhci-of-dwcmshc.c:684:9: error: implicit declaration of function 'dwcmshc_enable_card_clk' [-Werror=implicit-function-declaration]
     684 |         dwcmshc_enable_card_clk(host);
         |         ^~~~~~~~~~~~~~~~~~~~~~~

cc1: some warnings being treated as errors

vim +/dwcmshc_disable_card_clk +674 drivers/mmc/host/sdhci-of-dwcmshc.c

666
667 static int dwcmshc_runtime_suspend(struct device *dev)
668 {
669 struct sdhci_host *host = dev_get_drvdata(dev);
670 int ret = 0;
671
672 ret = sdhci_runtime_suspend_host(host);
673 if (!ret)

 > 674			dwcmshc_disable_card_clk(host);
   675	
   676		return ret;
   677	}
   678	
   679	static int dwcmshc_runtime_resume(struct device *dev)
   680	{
   681		struct sdhci_host *host = dev_get_drvdata(dev);
   682		int ret = 0;
   683	
 > 684		dwcmshc_enable_card_clk(host);

685 ret = sdhci_runtime_resume_host(host, 0);
686
687 return ret;
688 }
689

Signature · 2 lines
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests
author
#6 lore raw

PATCH v4 1/1 mmc: sdhci-of-dwcmshc: Add runtime PM operations

In reply to Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 54 ++++++++++++++++++++++++++++-
 1 file changed, 53 insertions(+), 1 deletion(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +53 -1
index e68cd87998c8..2d780a5bc8fb 100644
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -546,6 +547,8 @@ static int dwcmshc_probe(struct platform_device *pdev)
 		sdhci_enable_v4_mode(host);
 #endif
 
+	pm_runtime_enable(dev);
+
 	host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
 	err = sdhci_setup_host(host);
@@ -646,7 +649,56 @@ static int dwcmshc_resume(struct device *dev)
 }
 #endif
 
-static SIMPLE_DEV_PM_OPS(dwcmshc_pmops, dwcmshc_suspend, dwcmshc_resume);
+#ifdef CONFIG_PM
+
+static void dwcmshc_enable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	ctrl |= SDHCI_CLOCK_CARD_EN;
+	sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+}
+
+static void dwcmshc_disable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	ctrl &= ~SDHCI_CLOCK_CARD_EN;
+	sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+}
+
+static int dwcmshc_runtime_suspend(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+	int ret = 0;
+
+	ret = sdhci_runtime_suspend_host(host);
+	if (!ret)
+		dwcmshc_disable_card_clk(host);
+
+	return ret;
+}
+
+static int dwcmshc_runtime_resume(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+	int ret = 0;
+
+	dwcmshc_enable_card_clk(host);
+	ret = sdhci_runtime_resume_host(host, 0);
+
+	return ret;
+}
+
+#endif
+
+static const struct dev_pm_ops dwcmshc_pmops = {
+	SET_SYSTEM_SLEEP_PM_OPS(dwcmshc_suspend, dwcmshc_resume)
+	SET_RUNTIME_PM_OPS(dwcmshc_runtime_suspend,
+			   dwcmshc_runtime_resume, NULL)
+};
 
 static struct platform_driver sdhci_dwcmshc_driver = {
 	.driver	= {
Signature · 1 line
2.30.1
maintainer
#7 lore raw

Re: [PATCH v4] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 31 lines · Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 54 ++++++++++++++++++++++++++++-
 1 file changed, 53 insertions(+), 1 deletion(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +1 -0
index e68cd87998c8..2d780a5bc8fb 100644
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_probe(struct platform_device *pdev) · line 550

Quoted 4 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +1 -0
@@ -546,6 +547,8 @@ static int dwcmshc_probe(struct platform_device *pdev)
 		sdhci_enable_v4_mode(host);
 #endif
 
+	pm_runtime_enable(dev);

Is there a reason to call it this early? That raises questions about runtime PM racing with the rest of the host initialization. Perhaps below instead (note also using devm):

drivers/mmc/host/sdhci-of-dwcmshc.c +2 -2
index 2d780a5bc8fb..5cee42d72257 100644
@@ -547,8 +547,6 @@ static int dwcmshc_probe(struct platform_device *pdev)
 		sdhci_enable_v4_mode(host);
 #endif
 
-	pm_runtime_enable(dev);
-
 	host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
 	err = sdhci_setup_host(host);
@@ -562,6 +560,8 @@ static int dwcmshc_probe(struct platform_device *pdev)
 	if (err)
 		goto err_setup_host;
 
+	devm_pm_runtime_enable(dev);
+
 	return 0;
 
 err_setup_host:
Quoted 62 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +51 -1
+
 	host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
 	err = sdhci_setup_host(host);
@@ -646,7 +649,56 @@ static int dwcmshc_resume(struct device *dev)
 }
 #endif
 
-static SIMPLE_DEV_PM_OPS(dwcmshc_pmops, dwcmshc_suspend, dwcmshc_resume);
+#ifdef CONFIG_PM
+
+static void dwcmshc_enable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	ctrl |= SDHCI_CLOCK_CARD_EN;
+	sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+}
+
+static void dwcmshc_disable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	ctrl &= ~SDHCI_CLOCK_CARD_EN;
+	sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+}
+
+static int dwcmshc_runtime_suspend(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+	int ret = 0;
+
+	ret = sdhci_runtime_suspend_host(host);
+	if (!ret)
+		dwcmshc_disable_card_clk(host);
+
+	return ret;
+}
+
+static int dwcmshc_runtime_resume(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+	int ret = 0;
+
+	dwcmshc_enable_card_clk(host);
+	ret = sdhci_runtime_resume_host(host, 0);
+
+	return ret;
+}
+
+#endif
+
+static const struct dev_pm_ops dwcmshc_pmops = {
+	SET_SYSTEM_SLEEP_PM_OPS(dwcmshc_suspend, dwcmshc_resume)
+	SET_RUNTIME_PM_OPS(dwcmshc_runtime_suspend,
+			   dwcmshc_runtime_resume, NULL)
+};
 
 static struct platform_driver sdhci_dwcmshc_driver = {
 	.driver	= {
author
#8 lore raw

RE: [PATCH v4] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Done, updated in v5.
(sorry, not sure how I missed this comment earlier).

Quoted 143 lines

-----Original Message-----
From: Adrian Hunter <[email protected]>
Sent: Friday, May 19, 2023 9:19 AM
To: Liming Sun <[email protected]>; Ulf Hansson <[email protected]>; David Thompson <[email protected]>; Shawn Lin <shawn.lin@rock- chips.com>
Cc: [email protected]; [email protected]
Subject: Re: [PATCH v4] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 14 lines · Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

Quoted 2 lines
---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 54

++++++++++++++++++++++++++++-

drivers/mmc/host/sdhci-

Quoted 3 lines
 1 file changed, 53 insertions(+), 1 deletion(-)
drivers/mmc/host/sdhci- renamed from drivers/mmc/host/sdhci-of-dwcmshc.c +0 -0

of-dwcmshc.c

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_probe(struct platform_device

Quoted 12 lines

index e68cd87998c8..2d780a5bc8fb 100644

drivers/mmc/host/sdhci-of-dwcmshc.c +1 -0
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -546,6 +547,8 @@ static int dwcmshc_probe(struct platform_device

*pdev)

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_probe(struct platform_device *pdev)

Quoted 4 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +1 -0
 		sdhci_enable_v4_mode(host);
 #endif
 
+	pm_runtime_enable(dev);

Is there a reason to call it this early? That raises questions about runtime PM racing with the rest of the host initialization. Perhaps below instead (note also using devm):

drivers/mmc/host/sdhci- renamed from drivers/mmc/host/sdhci-of-dwcmshc.c +0 -0

of-dwcmshc.c
index 2d780a5bc8fb..5cee42d72257 100644

drivers/mmc/host/sdhci-of-dwcmshc.c +0 -2
@@ -547,8 +547,6 @@ static int dwcmshc_probe(struct platform_device
 *pdev)
 		sdhci_enable_v4_mode(host);
 #endif
 
-	pm_runtime_enable(dev);
-
 	host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
drivers/mmc/host/sdhci-of-dwcmshc.c +2 -0
 	err = sdhci_setup_host(host);
@@ -562,6 +560,8 @@ static int dwcmshc_probe(struct platform_device
 *pdev)
 	if (err)
 		goto err_setup_host;
 
+	devm_pm_runtime_enable(dev);
+
 	return 0;
 

err_setup_host:

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 649

Quoted 9 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +1 -1
+
 	host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
 	err = sdhci_setup_host(host);
@@ -646,7 +649,56 @@ static int dwcmshc_resume(struct device *dev)
 }
 #endif
 
-static SIMPLE_DEV_PM_OPS(dwcmshc_pmops, dwcmshc_suspend,

dwcmshc_resume);

Quoted 53 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +50 -0
+#ifdef CONFIG_PM
+
+static void dwcmshc_enable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	ctrl |= SDHCI_CLOCK_CARD_EN;
+	sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+}
+
+static void dwcmshc_disable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	ctrl &= ~SDHCI_CLOCK_CARD_EN;
+	sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+}
+
+static int dwcmshc_runtime_suspend(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+	int ret = 0;
+
+	ret = sdhci_runtime_suspend_host(host);
+	if (!ret)
+		dwcmshc_disable_card_clk(host);
+
+	return ret;
+}
+
+static int dwcmshc_runtime_resume(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+	int ret = 0;
+
+	dwcmshc_enable_card_clk(host);
+	ret = sdhci_runtime_resume_host(host, 0);
+
+	return ret;
+}
+
+#endif
+
+static const struct dev_pm_ops dwcmshc_pmops = {
+	SET_SYSTEM_SLEEP_PM_OPS(dwcmshc_suspend, dwcmshc_resume)
+	SET_RUNTIME_PM_OPS(dwcmshc_runtime_suspend,
+			   dwcmshc_runtime_resume, NULL)
+};
 
 static struct platform_driver sdhci_dwcmshc_driver = {
 	.driver	= {
author
#9 lore raw

PATCH v5 1/1 mmc: sdhci-of-dwcmshc: Add runtime PM operations

In reply to Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 54 ++++++++++++++++++++++++++++-
 1 file changed, 53 insertions(+), 1 deletion(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +53 -1
index e68cd87998c8..5cee42d72257 100644
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -559,6 +560,8 @@ static int dwcmshc_probe(struct platform_device *pdev)
 	if (err)
 		goto err_setup_host;
 
+	devm_pm_runtime_enable(dev);
+
 	return 0;
 
 err_setup_host:
@@ -646,7 +649,56 @@ static int dwcmshc_resume(struct device *dev)
 }
 #endif
 
-static SIMPLE_DEV_PM_OPS(dwcmshc_pmops, dwcmshc_suspend, dwcmshc_resume);
+#ifdef CONFIG_PM
+
+static void dwcmshc_enable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	ctrl |= SDHCI_CLOCK_CARD_EN;
+	sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+}
+
+static void dwcmshc_disable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	ctrl &= ~SDHCI_CLOCK_CARD_EN;
+	sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+}
+
+static int dwcmshc_runtime_suspend(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+	int ret = 0;
+
+	ret = sdhci_runtime_suspend_host(host);
+	if (!ret)
+		dwcmshc_disable_card_clk(host);
+
+	return ret;
+}
+
+static int dwcmshc_runtime_resume(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+	int ret = 0;
+
+	dwcmshc_enable_card_clk(host);
+	ret = sdhci_runtime_resume_host(host, 0);
+
+	return ret;
+}
+
+#endif
+
+static const struct dev_pm_ops dwcmshc_pmops = {
+	SET_SYSTEM_SLEEP_PM_OPS(dwcmshc_suspend, dwcmshc_resume)
+	SET_RUNTIME_PM_OPS(dwcmshc_runtime_suspend,
+			   dwcmshc_runtime_resume, NULL)
+};
 
 static struct platform_driver sdhci_dwcmshc_driver = {
 	.driver	= {
Signature · 1 line
2.30.1
maintainer
#10 lore raw

Re: [PATCH v5] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 34 lines · Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 54 ++++++++++++++++++++++++++++-
 1 file changed, 53 insertions(+), 1 deletion(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +1 -0
index e68cd87998c8..5cee42d72257 100644
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_probe(struct platform_device *pdev) · line 563

Quoted 4 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +1 -0
@@ -559,6 +560,8 @@ static int dwcmshc_probe(struct platform_device *pdev)
 	if (err)
 		goto err_setup_host;
 
+	devm_pm_runtime_enable(dev);

By default, runtime PM regards the device as not active, so typically drivers will use something like pm_runtime_set_active() prior to pm_runtime_enable(dev)

In fact it is better to enable before adding the host but increment the usage count to prevent runtime suspend. That means adding some get/puts, ending up with something like:

+ pm_runtime_get_noresume(dev);
+ pm_runtime_set_active(dev);
+ pm_runtime_enable(dev);

	err = sdhci_setup_host(host);
	if (err)

- goto err_clk;
+ goto err_rpm;

	if (rk_priv)
		dwcmshc_rk35xx_postinit(host, priv);

	err = __sdhci_add_host(host);
	if (err)
		goto err_setup_host;

+ pm_runtime_put_sync(dev);

	return 0;

err_setup_host:

	sdhci_cleanup_host(host);

+ err_rpm:
+ pm_runtime_disable(dev);
+ pm_runtime_put_noidle(dev);
err_clk:

	clk_disable_unprepare(pltfm_host->clk);
	clk_disable_unprepare(priv->bus_clk);
	if (rk_priv)
		clk_bulk_disable_unprepare(RK35xx_MAX_CLKS,
					   rk_priv->rockchip_clks);
free_pltfm:
	sdhci_pltfm_free(pdev);
	return err;
Quoted 6 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +1 -0
+
 	return 0;
 
 err_setup_host:
@@ -646,7 +649,56 @@ static int dwcmshc_resume(struct device *dev)
 }

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 658

Quoted 10 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +7 -1
 #endif
 
-static SIMPLE_DEV_PM_OPS(dwcmshc_pmops, dwcmshc_suspend, dwcmshc_resume);
+#ifdef CONFIG_PM
+
+static void dwcmshc_enable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);

You could save an mmio write:

	if (ctrl & SDHCI_CLOCK_INT_EN && !(ctrl & SDHCI_CLOCK_CARD_EN)) {

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 660

Quoted 2 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +2 -0
+	ctrl |= SDHCI_CLOCK_CARD_EN;
+	sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
	}

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 667

Quoted 7 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +7 -0
+}
+
+static void dwcmshc_disable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);

You could save an mmio write:

	if (ctrl & SDHCI_CLOCK_CARD_EN) {

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 669

Quoted 2 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +2 -0
+	ctrl &= ~SDHCI_CLOCK_CARD_EN;
+	sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
	}

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 675

Quoted 6 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +6 -0
+}
+
+static int dwcmshc_runtime_suspend(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+	int ret = 0;

ret doesn't need initialization

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 677

Quoted 2 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +2 -0
+
+	ret = sdhci_runtime_suspend_host(host);

If you *only* want to disable the card clock, then
it is probably not necessary to call sdhci_runtime_suspend_host() and sdhci_runtime_resume_host().

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 687

Quoted 10 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +10 -0
+	if (!ret)
+		dwcmshc_disable_card_clk(host);
+
+	return ret;
+}
+
+static int dwcmshc_runtime_resume(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+	int ret = 0;

ret isn't needed

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 690

Quoted 3 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +3 -0
+
+	dwcmshc_enable_card_clk(host);
+	ret = sdhci_runtime_resume_host(host, 0);

just

	return sdhci_runtime_resume_host(host, 0);

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 698

Quoted 8 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +8 -0
+
+	return ret;
+}
+
+#endif
+
+static const struct dev_pm_ops dwcmshc_pmops = {
+	SET_SYSTEM_SLEEP_PM_OPS(dwcmshc_suspend, dwcmshc_resume)

Typically you need a way to coordinate runtime PM and system PM, refer:

https://www.kernel.org/doc/html/latest/power/runtime_pm.html#runtime-pm-and-system-sleep

Quoted 6 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +3 -0
+	SET_RUNTIME_PM_OPS(dwcmshc_runtime_suspend,
+			   dwcmshc_runtime_resume, NULL)
+};
 
 static struct platform_driver sdhci_dwcmshc_driver = {
 	.driver	= {
author
#11 lore raw

RE: [PATCH v5] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 88 lines

-----Original Message-----
From: Adrian Hunter <[email protected]>
Sent: Tuesday, August 1, 2023 11:37 AM
To: Liming Sun <[email protected]>; Ulf Hansson <[email protected]>; David Thompson <[email protected]>; Shawn Lin <shawn.lin@rock- chips.com>
Cc: [email protected]; [email protected]
Subject: Re: [PATCH v5] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 17 lines · Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

Quoted 2 lines
---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 54

++++++++++++++++++++++++++++-

drivers/mmc/host/sdhci-

Quoted 3 lines
 1 file changed, 53 insertions(+), 1 deletion(-)
drivers/mmc/host/sdhci- renamed from drivers/mmc/host/sdhci-of-dwcmshc.c +0 -0

of-dwcmshc.c

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_probe(struct platform_device

Quoted 12 lines

index e68cd87998c8..5cee42d72257 100644

drivers/mmc/host/sdhci-of-dwcmshc.c +1 -0
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -559,6 +560,8 @@ static int dwcmshc_probe(struct platform_device

*pdev)

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_probe(struct platform_device *pdev) · line 563

Quoted 4 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +1 -0
 	if (err)
 		goto err_setup_host;
 
+	devm_pm_runtime_enable(dev);

By default, runtime PM regards the device as not active, so typically drivers will use something like pm_runtime_set_active() prior to pm_runtime_enable(dev)

In fact it is better to enable before adding the host but increment the usage count to prevent runtime suspend. That means adding some get/puts, ending up with something like:

(quoted diff) +3 -0
+	pm_runtime_get_noresume(dev);
+	pm_runtime_set_active(dev);
+	pm_runtime_enable(dev);
	err = sdhci_setup_host(host);
	if (err)
(quoted diff) +1 -1
-		goto err_clk;
+		goto err_rpm;
	if (rk_priv)
		dwcmshc_rk35xx_postinit(host, priv);

	err = __sdhci_add_host(host);
	if (err)
		goto err_setup_host;
(quoted diff) +1 -0
+	pm_runtime_put_sync(dev);
	return 0;

err_setup_host:

	sdhci_cleanup_host(host);

+ err_rpm:

(quoted diff) +2 -0
+	pm_runtime_disable(dev);
+	pm_runtime_put_noidle(dev);

err_clk:

Quoted 9 lines
	clk_disable_unprepare(pltfm_host->clk);
	clk_disable_unprepare(priv->bus_clk);
	if (rk_priv)
		clk_bulk_disable_unprepare(RK35xx_MAX_CLKS,
					   rk_priv->rockchip_clks);
free_pltfm:
	sdhci_pltfm_free(pdev);
	return err;

Updated in v6.

Quoted 20 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 649

Quoted 9 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +1 -1
+
 	return 0;
 
 err_setup_host:
@@ -646,7 +649,56 @@ static int dwcmshc_resume(struct device *dev)
 }
 #endif
 
-static SIMPLE_DEV_PM_OPS(dwcmshc_pmops, dwcmshc_suspend,

dwcmshc_resume);

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 658

Quoted 7 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +7 -0
+#ifdef CONFIG_PM
+
+static void dwcmshc_enable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);

You could save an mmio write:

Quoted 6 lines
	if (ctrl & SDHCI_CLOCK_INT_EN && !(ctrl & SDHCI_CLOCK_CARD_EN)) {

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 660

Quoted 2 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +2 -0
+	ctrl |= SDHCI_CLOCK_CARD_EN;
+	sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
	}

Updated in v6.

Quoted 11 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 667

Quoted 8 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +7 -0
+}
+
+static void dwcmshc_disable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);

You could save an mmio write:

Quoted 6 lines
	if (ctrl & SDHCI_CLOCK_CARD_EN) {

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 669

Quoted 2 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +2 -0
+	ctrl &= ~SDHCI_CLOCK_CARD_EN;
+	sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
	}

Updated in v6.

Quoted 9 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 675

Quoted 7 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +6 -0
+}
+
+static int dwcmshc_runtime_suspend(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+	int ret = 0;

ret doesn't need initialization

Updated in v6.

Quoted 8 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 677

Quoted 3 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +2 -0
+
+	ret = sdhci_runtime_suspend_host(host);

If you *only* want to disable the card clock, then
it is probably not necessary to call sdhci_runtime_suspend_host() and sdhci_runtime_resume_host().

If, only cares about the card clock. Tested and removed the sdhci_runtime_suspend_host() and sdhci_runtime_resume_host() to keep it simple.

Quoted 4 lines
Quoted 4 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +4 -0
+	if (!ret)
+		dwcmshc_disable_card_clk(host);
+
+	return ret;
Quoted 8 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 687

Quoted 6 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +6 -0
+}
+
+static int dwcmshc_runtime_resume(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+	int ret = 0;

ret isn't needed

Removed in v6.

Quoted 7 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 690

Quoted 4 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +3 -0
+
+	dwcmshc_enable_card_clk(host);
+	ret = sdhci_runtime_resume_host(host, 0);

just

	return sdhci_runtime_resume_host(host, 0);

Updated in v6.

Quoted 12 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 698

Quoted 9 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +8 -0
+
+	return ret;
+}
+
+#endif
+
+static const struct dev_pm_ops dwcmshc_pmops = {
+	SET_SYSTEM_SLEEP_PM_OPS(dwcmshc_suspend, dwcmshc_resume)

Typically you need a way to coordinate runtime PM and system PM, refer:

Quoted 2 lines

https://www.kernel.org/doc/html/latest/power/runtime_pm.html#runtime-
pm-and-system-sleep

Thanks. Added pm_runtime_force_suspend() and pm_runtime_force_resume() in the system sleep() and resume() function to make the two states consistent.

Quoted 7 lines
Quoted 7 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +3 -0
+	SET_RUNTIME_PM_OPS(dwcmshc_runtime_suspend,
+			   dwcmshc_runtime_resume, NULL)
+};
 
 static struct platform_driver sdhci_dwcmshc_driver = {
 	.driver	= {
author
#12 lore raw

PATCH v6 1/1 mmc: sdhci-of-dwcmshc: Add runtime PM operations

In reply to Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v5->v6:
- Address Adrian's more comments and add coordination between runtime PM and system PM;
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 72 ++++++++++++++++++++++++++++-
 1 file changed, 70 insertions(+), 2 deletions(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +70 -2
index e68cd87998c8..aaf66358f626 100644
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -548,9 +549,13 @@ static int dwcmshc_probe(struct platform_device *pdev)
 
 	host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
+	pm_runtime_get_noresume(dev);
+	pm_runtime_set_active(dev);
+	pm_runtime_enable(dev);
+
 	err = sdhci_setup_host(host);
 	if (err)
-		goto err_clk;
+		goto err_rpm;
 
 	if (rk_priv)
 		dwcmshc_rk35xx_postinit(host, priv);
@@ -559,10 +564,15 @@ static int dwcmshc_probe(struct platform_device *pdev)
 	if (err)
 		goto err_setup_host;
 
+	pm_runtime_put_sync(dev);
+
 	return 0;
 
 err_setup_host:
 	sdhci_cleanup_host(host);
+err_rpm:
+	pm_runtime_disable(dev);
+	pm_runtime_put_noidle(dev);
 err_clk:
 	clk_disable_unprepare(pltfm_host->clk);
 	clk_disable_unprepare(priv->bus_clk);
@@ -606,6 +616,12 @@ static int dwcmshc_suspend(struct device *dev)
 	if (ret)
 		return ret;
 
+	ret = pm_runtime_force_suspend(dev);
+	if (ret) {
+		sdhci_resume_host(host);
+		return ret;
+	}
+
 	clk_disable_unprepare(pltfm_host->clk);
 	if (!IS_ERR(priv->bus_clk))
 		clk_disable_unprepare(priv->bus_clk);
@@ -625,6 +641,10 @@ static int dwcmshc_resume(struct device *dev)
 	struct rk35xx_priv *rk_priv = priv->priv;
 	int ret;
 
+	ret = pm_runtime_force_resume(dev);
+	if (ret)
+		return ret;
+
 	ret = clk_prepare_enable(pltfm_host->clk);
 	if (ret)
 		return ret;
@@ -646,7 +666,55 @@ static int dwcmshc_resume(struct device *dev)
 }
 #endif
 
-static SIMPLE_DEV_PM_OPS(dwcmshc_pmops, dwcmshc_suspend, dwcmshc_resume);
+#ifdef CONFIG_PM
+
+static void dwcmshc_enable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	if ((ctrl & SDHCI_CLOCK_INT_EN) && !(ctrl & SDHCI_CLOCK_CARD_EN)) {
+		ctrl |= SDHCI_CLOCK_CARD_EN;
+		sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+	}
+}
+
+static void dwcmshc_disable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	if (ctrl & SDHCI_CLOCK_CARD_EN) {
+		ctrl &= ~SDHCI_CLOCK_CARD_EN;
+		sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+	}
+}
+
+static int dwcmshc_runtime_suspend(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+
+	dwcmshc_disable_card_clk(host);
+
+	return 0;
+}
+
+static int dwcmshc_runtime_resume(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+
+	dwcmshc_enable_card_clk(host);
+
+	return 0;
+}
+
+#endif
+
+static const struct dev_pm_ops dwcmshc_pmops = {
+	SET_SYSTEM_SLEEP_PM_OPS(dwcmshc_suspend, dwcmshc_resume)
+	SET_RUNTIME_PM_OPS(dwcmshc_runtime_suspend,
+			   dwcmshc_runtime_resume, NULL)
+};
 
 static struct platform_driver sdhci_dwcmshc_driver = {
 	.driver	= {
Signature · 1 line
2.30.1
#13 lore raw

Re: [PATCH v6] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 53 lines · Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v5->v6:
- Address Adrian's more comments and add coordination between runtime PM and system PM;
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 72 ++++++++++++++++++++++++++++-
 1 file changed, 70 insertions(+), 2 deletions(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +6 -1
index e68cd87998c8..aaf66358f626 100644
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -548,9 +549,13 @@ static int dwcmshc_probe(struct platform_device *pdev)
 
        host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
+       pm_runtime_get_noresume(dev);
+       pm_runtime_set_active(dev);
+       pm_runtime_enable(dev);
+
        err = sdhci_setup_host(host);
        if (err)
-               goto err_clk;
+               goto err_rpm;
 
        if (rk_priv)
                dwcmshc_rk35xx_postinit(host, priv);

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_probe(struct platform_device *pdev) · line 568

Quoted 5 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +2 -0
@@ -559,10 +564,15 @@ static int dwcmshc_probe(struct platform_device *pdev)
        if (err)
                goto err_setup_host;
 
+       pm_runtime_put_sync(dev);
+

The async pm_runtime_put() is probably sufficient - and it would allow the probe to complete a bit "sooner".

Quoted 11 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +3 -0
        return 0;
 
 err_setup_host:
        sdhci_cleanup_host(host);
+err_rpm:
+       pm_runtime_disable(dev);
+       pm_runtime_put_noidle(dev);
 err_clk:
        clk_disable_unprepare(pltfm_host->clk);
        clk_disable_unprepare(priv->bus_clk);

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_suspend(struct device *dev) · line 619

Quoted 4 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +1 -0
@@ -606,6 +616,12 @@ static int dwcmshc_suspend(struct device *dev)
        if (ret)
                return ret;
 
+       ret = pm_runtime_force_suspend(dev);

Can dwcmshc_suspend() be called for a device that may be attached to the ACPI PM domain?

Quoted 67 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +52 -1
+       if (ret) {
+               sdhci_resume_host(host);
+               return ret;
+       }
+
        clk_disable_unprepare(pltfm_host->clk);
        if (!IS_ERR(priv->bus_clk))
                clk_disable_unprepare(priv->bus_clk);
@@ -625,6 +641,10 @@ static int dwcmshc_resume(struct device *dev)
        struct rk35xx_priv *rk_priv = priv->priv;
        int ret;
 
+       ret = pm_runtime_force_resume(dev);
+       if (ret)
+               return ret;
+
        ret = clk_prepare_enable(pltfm_host->clk);
        if (ret)
                return ret;
@@ -646,7 +666,55 @@ static int dwcmshc_resume(struct device *dev)
 }
 #endif
 
-static SIMPLE_DEV_PM_OPS(dwcmshc_pmops, dwcmshc_suspend, dwcmshc_resume);
+#ifdef CONFIG_PM
+
+static void dwcmshc_enable_card_clk(struct sdhci_host *host)
+{
+       u16 ctrl;
+
+       ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+       if ((ctrl & SDHCI_CLOCK_INT_EN) && !(ctrl & SDHCI_CLOCK_CARD_EN)) {
+               ctrl |= SDHCI_CLOCK_CARD_EN;
+               sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+       }
+}
+
+static void dwcmshc_disable_card_clk(struct sdhci_host *host)
+{
+       u16 ctrl;
+
+       ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+       if (ctrl & SDHCI_CLOCK_CARD_EN) {
+               ctrl &= ~SDHCI_CLOCK_CARD_EN;
+               sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+       }
+}
+
+static int dwcmshc_runtime_suspend(struct device *dev)
+{
+       struct sdhci_host *host = dev_get_drvdata(dev);
+
+       dwcmshc_disable_card_clk(host);
+
+       return 0;
+}
+
+static int dwcmshc_runtime_resume(struct device *dev)
+{
+       struct sdhci_host *host = dev_get_drvdata(dev);
+
+       dwcmshc_enable_card_clk(host);
+
+       return 0;
+}
+
+#endif

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev)

Quoted 10 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +6 -1
+
+static const struct dev_pm_ops dwcmshc_pmops = {
+       SET_SYSTEM_SLEEP_PM_OPS(dwcmshc_suspend, dwcmshc_resume)
+       SET_RUNTIME_PM_OPS(dwcmshc_runtime_suspend,
+                          dwcmshc_runtime_resume, NULL)
+};
 
 static struct platform_driver sdhci_dwcmshc_driver = {
        .driver = {
--

Kind regards
Uffe

author
#14 lore raw

RE: [PATCH v6] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 69 lines

-----Original Message-----
From: Ulf Hansson <[email protected]>
Sent: Tuesday, August 8, 2023 5:40 AM
To: Liming Sun <[email protected]>
Cc: Adrian Hunter <[email protected]>; David Thompson <[email protected]>; Shawn Lin <[email protected]>; linux- [email protected]; [email protected]
Subject: Re: [PATCH v6] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 21 lines · Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v5->v6:
- Address Adrian's more comments and add coordination between runtime PM and system PM;
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

Quoted 2 lines
---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 72

++++++++++++++++++++++++++++-

drivers/mmc/host/sdhci-

Quoted 3 lines
 1 file changed, 70 insertions(+), 2 deletions(-)
drivers/mmc/host/sdhci- renamed from drivers/mmc/host/sdhci-of-dwcmshc.c +0 -0

of-dwcmshc.c

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_probe(struct platform_device

Quoted 12 lines

index e68cd87998c8..aaf66358f626 100644

drivers/mmc/host/sdhci-of-dwcmshc.c +1 -0
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -548,9 +549,13 @@ static int dwcmshc_probe(struct platform_device

*pdev)

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_probe(struct platform_device

Quoted 15 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +5 -1
        host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
+       pm_runtime_get_noresume(dev);
+       pm_runtime_set_active(dev);
+       pm_runtime_enable(dev);
+
        err = sdhci_setup_host(host);
        if (err)
-               goto err_clk;
+               goto err_rpm;
 
        if (rk_priv)
                dwcmshc_rk35xx_postinit(host, priv);
@@ -559,10 +564,15 @@ static int dwcmshc_probe(struct platform_device

*pdev)

Quoted 8 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_probe(struct platform_device *pdev) · line 568

Quoted 5 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +2 -0
        if (err)
                goto err_setup_host;
 
+       pm_runtime_put_sync(dev);
+

The async pm_runtime_put() is probably sufficient - and it would allow the probe to complete a bit "sooner".

Sure, will test and update the line in v7.

Quoted 15 lines
Quoted 15 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +3 -0
        return 0;
 
 err_setup_host:
        sdhci_cleanup_host(host);
+err_rpm:
+       pm_runtime_disable(dev);
+       pm_runtime_put_noidle(dev);
 err_clk:
        clk_disable_unprepare(pltfm_host->clk);
        clk_disable_unprepare(priv->bus_clk);
@@ -606,6 +616,12 @@ static int dwcmshc_suspend(struct device *dev)
        if (ret)
                return ret;
 
Quoted 4 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_suspend(struct device *dev) · line 619

Quoted 1 line
drivers/mmc/host/sdhci-of-dwcmshc.c +1 -0
+       ret = pm_runtime_force_suspend(dev);

Can dwcmshc_suspend() be called for a device that may be attached to the ACPI PM domain?

BlueField SoC is the only chip that uses ACPI in this driver for now and it doesn't support System Sleep. Thus, the dwcmshc_suspend() won't be called. But I guess it might be possible when other new chip support is added into this driver. Is it a concern?

Quoted 83 lines
Quoted 21 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +9 -0
+       if (ret) {
+               sdhci_resume_host(host);
+               return ret;
+       }
+
        clk_disable_unprepare(pltfm_host->clk);
        if (!IS_ERR(priv->bus_clk))
                clk_disable_unprepare(priv->bus_clk);
@@ -625,6 +641,10 @@ static int dwcmshc_resume(struct device *dev)
        struct rk35xx_priv *rk_priv = priv->priv;
        int ret;
 
+       ret = pm_runtime_force_resume(dev);
+       if (ret)
+               return ret;
+
        ret = clk_prepare_enable(pltfm_host->clk);
        if (ret)
                return ret;

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 649

Quoted 4 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +0 -1
@@ -646,7 +666,55 @@ static int dwcmshc_resume(struct device *dev)
 }
 #endif
 
-static SIMPLE_DEV_PM_OPS(dwcmshc_pmops, dwcmshc_suspend,

dwcmshc_resume);

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev)

Quoted 8 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +8 -0
+#ifdef CONFIG_PM
+
+static void dwcmshc_enable_card_clk(struct sdhci_host *host)
+{
+       u16 ctrl;
+
+       ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+       if ((ctrl & SDHCI_CLOCK_INT_EN) && !(ctrl & SDHCI_CLOCK_CARD_EN))

{

Quoted 35 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +35 -0
+               ctrl |= SDHCI_CLOCK_CARD_EN;
+               sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+       }
+}
+
+static void dwcmshc_disable_card_clk(struct sdhci_host *host)
+{
+       u16 ctrl;
+
+       ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+       if (ctrl & SDHCI_CLOCK_CARD_EN) {
+               ctrl &= ~SDHCI_CLOCK_CARD_EN;
+               sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+       }
+}
+
+static int dwcmshc_runtime_suspend(struct device *dev)
+{
+       struct sdhci_host *host = dev_get_drvdata(dev);
+
+       dwcmshc_disable_card_clk(host);
+
+       return 0;
+}
+
+static int dwcmshc_runtime_resume(struct device *dev)
+{
+       struct sdhci_host *host = dev_get_drvdata(dev);
+
+       dwcmshc_enable_card_clk(host);
+
+       return 0;
+}
+
+#endif

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev)

Quoted 10 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +6 -1
+
+static const struct dev_pm_ops dwcmshc_pmops = {
+       SET_SYSTEM_SLEEP_PM_OPS(dwcmshc_suspend, dwcmshc_resume)
+       SET_RUNTIME_PM_OPS(dwcmshc_runtime_suspend,
+                          dwcmshc_runtime_resume, NULL)
+};
 
 static struct platform_driver sdhci_dwcmshc_driver = {
        .driver = {
--

Kind regards
Uffe

#15 lore raw

Re: [PATCH v6] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 96 lines · Liming Sun
Quoted 70 lines

-----Original Message-----
From: Ulf Hansson <[email protected]>
Sent: Tuesday, August 8, 2023 5:40 AM
To: Liming Sun <[email protected]>
Cc: Adrian Hunter <[email protected]>; David Thompson <[email protected]>; Shawn Lin <[email protected]>; linux- [email protected]; [email protected]
Subject: Re: [PATCH v6] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 21 lines · Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v5->v6:
- Address Adrian's more comments and add coordination between runtime PM and system PM;
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

Quoted 2 lines
---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 72

++++++++++++++++++++++++++++-

drivers/mmc/host/sdhci-

Quoted 3 lines
 1 file changed, 70 insertions(+), 2 deletions(-)
drivers/mmc/host/sdhci- renamed from drivers/mmc/host/sdhci-of-dwcmshc.c +0 -0

of-dwcmshc.c

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_probe(struct platform_device

Quoted 12 lines

index e68cd87998c8..aaf66358f626 100644

drivers/mmc/host/sdhci-of-dwcmshc.c +1 -0
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -548,9 +549,13 @@ static int dwcmshc_probe(struct platform_device

*pdev)

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_probe(struct platform_device

Quoted 15 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +5 -1
        host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
+       pm_runtime_get_noresume(dev);
+       pm_runtime_set_active(dev);
+       pm_runtime_enable(dev);
+
        err = sdhci_setup_host(host);
        if (err)
-               goto err_clk;
+               goto err_rpm;
 
        if (rk_priv)
                dwcmshc_rk35xx_postinit(host, priv);
@@ -559,10 +564,15 @@ static int dwcmshc_probe(struct platform_device

*pdev)

Quoted 8 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_probe(struct platform_device *pdev) · line 568

Quoted 5 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +2 -0
        if (err)
                goto err_setup_host;
 
+       pm_runtime_put_sync(dev);
+

The async pm_runtime_put() is probably sufficient - and it would allow the probe to complete a bit "sooner".

Sure, will test and update the line in v7.

Quoted 15 lines
Quoted 15 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +3 -0
        return 0;
 
 err_setup_host:
        sdhci_cleanup_host(host);
+err_rpm:
+       pm_runtime_disable(dev);
+       pm_runtime_put_noidle(dev);
 err_clk:
        clk_disable_unprepare(pltfm_host->clk);
        clk_disable_unprepare(priv->bus_clk);
@@ -606,6 +616,12 @@ static int dwcmshc_suspend(struct device *dev)
        if (ret)
                return ret;
 
Quoted 6 lines
Quoted 4 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_suspend(struct device *dev) · line 619

Quoted 1 line
drivers/mmc/host/sdhci-of-dwcmshc.c +1 -0
+       ret = pm_runtime_force_suspend(dev);

Can dwcmshc_suspend() be called for a device that may be attached to the ACPI PM domain?

BlueField SoC is the only chip that uses ACPI in this driver for now and it doesn't support System Sleep. Thus, the dwcmshc_suspend() won't be called. But I guess it might be possible when other new chip support is added into this driver. Is it a concern?

The ACPI PM domain doesn't support drivers using pm_runtime_force_suspend|resume(). Unless that has been changed without me knowing about it.

Anyway, it looks like it shouldn't be a problem at this point. We can also add separate callbacks for other SoCs, if that comes into play going forward.

[...]

Kind regards
Uffe

author
#16 lore raw

RE: [PATCH v6] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 123 lines

-----Original Message-----
From: Ulf Hansson <[email protected]>
Sent: Tuesday, August 8, 2023 9:57 AM
To: Liming Sun <[email protected]>
Cc: Adrian Hunter <[email protected]>; David Thompson <[email protected]>; Shawn Lin <[email protected]>; linux- [email protected]; [email protected]
Subject: Re: [PATCH v6] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 9 lines · Liming Sun
Quoted 9 lines

-----Original Message-----
From: Ulf Hansson <[email protected]>
Sent: Tuesday, August 8, 2023 5:40 AM
To: Liming Sun <[email protected]>
Cc: Adrian Hunter <[email protected]>; David Thompson <[email protected]>; Shawn Lin <[email protected]>;

linux-

Quoted 2 lines
Quoted 2 lines

[email protected]; [email protected]
Subject: Re: [PATCH v6] mmc: sdhci-of-dwcmshc: Add runtime PM

operations

Quoted 25 lines
Quoted 25 lines · Liming Sun
Quoted 23 lines

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v5->v6:
- Address Adrian's more comments and add coordination between runtime PM and system PM;
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 72
Quoted 4 lines
Quoted 4 lines

++++++++++++++++++++++++++++-

Review

Quoted 3 lines
 1 file changed, 70 insertions(+), 2 deletions(-)
(quoted diff) +0 -0

b/drivers/mmc/host/sdhci-

Quoted 12 lines
Quoted 12 lines

of-dwcmshc.c

Quoted 11 lines

index e68cd87998c8..aaf66358f626 100644

drivers/mmc/host/sdhci-of-dwcmshc.c +1 -0
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
Quoted 1 line
Quoted 1 line

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_probe(struct

Quoted 1 line
drivers/mmc/host/sdhci-of-dwcmshc.c +0 -0
@@ -548,9 +549,13 @@ static int dwcmshc_probe(struct

platform_device

Quoted 13 lines
Quoted 13 lines

*pdev)

Quoted 12 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +5 -1
        host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
+       pm_runtime_get_noresume(dev);
+       pm_runtime_set_active(dev);
+       pm_runtime_enable(dev);
+
        err = sdhci_setup_host(host);
        if (err)
-               goto err_clk;
+               goto err_rpm;
 
Quoted 3 lines
Quoted 3 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_probe(struct

Quoted 3 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +0 -0
        if (rk_priv)
                dwcmshc_rk35xx_postinit(host, priv);
@@ -559,10 +564,15 @@ static int dwcmshc_probe(struct

platform_device

Quoted 27 lines
Quoted 9 lines

*pdev)

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_probe(struct platform_device *pdev) · line 568

Quoted 5 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +2 -0
        if (err)
                goto err_setup_host;
 
+       pm_runtime_put_sync(dev);
+

The async pm_runtime_put() is probably sufficient - and it would allow the probe to complete a bit "sooner".

Sure, will test and update the line in v7.

Quoted 15 lines
Quoted 15 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +3 -0
        return 0;
 
 err_setup_host:
        sdhci_cleanup_host(host);
+err_rpm:
+       pm_runtime_disable(dev);
+       pm_runtime_put_noidle(dev);
 err_clk:
        clk_disable_unprepare(pltfm_host->clk);
        clk_disable_unprepare(priv->bus_clk);
@@ -606,6 +616,12 @@ static int dwcmshc_suspend(struct device *dev)
        if (ret)
                return ret;
 
Quoted 6 lines
Quoted 4 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_suspend(struct device *dev) · line 619

Quoted 1 line
drivers/mmc/host/sdhci-of-dwcmshc.c +1 -0
+       ret = pm_runtime_force_suspend(dev);

Can dwcmshc_suspend() be called for a device that may be attached to the ACPI PM domain?

BlueField SoC is the only chip that uses ACPI in this driver for now and it

doesn't support System Sleep. Thus, the dwcmshc_suspend() won't be called. But I guess it might be possible when other new chip support is added into this driver. Is it a concern?

Quoted 7 lines

The ACPI PM domain doesn't support drivers using pm_runtime_force_suspend|resume(). Unless that has been changed without me knowing about it.

Anyway, it looks like it shouldn't be a problem at this point. We can also add separate callbacks for other SoCs, if that comes into play going forward.

Thanks. So no further changes for now.
Posted v7 (for the other comment).

Quoted 5 lines

[...]

Kind regards
Uffe

#17 lore raw

Re: [PATCH v6] mmc: sdhci-of-dwcmshc: Add runtime PM operations

In reply to Liming Sun
Quoted 69 lines · Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v5->v6:
- Address Adrian's more comments and add coordination between runtime PM and system PM;
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 72 ++++++++++++++++++++++++++++-
 1 file changed, 70 insertions(+), 2 deletions(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +11 -1
index e68cd87998c8..aaf66358f626 100644
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -548,9 +549,13 @@ static int dwcmshc_probe(struct platform_device *pdev)
 
        host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
+       pm_runtime_get_noresume(dev);
+       pm_runtime_set_active(dev);
+       pm_runtime_enable(dev);
+
        err = sdhci_setup_host(host);
        if (err)
-               goto err_clk;
+               goto err_rpm;
 
        if (rk_priv)
                dwcmshc_rk35xx_postinit(host, priv);
@@ -559,10 +564,15 @@ static int dwcmshc_probe(struct platform_device *pdev)
        if (err)
                goto err_setup_host;
 
+       pm_runtime_put_sync(dev);
+
        return 0;
 
 err_setup_host:
        sdhci_cleanup_host(host);
+err_rpm:
+       pm_runtime_disable(dev);
+       pm_runtime_put_noidle(dev);
 err_clk:
        clk_disable_unprepare(pltfm_host->clk);
        clk_disable_unprepare(priv->bus_clk);

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_suspend(struct device *dev) · line 618

Quoted 3 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +0 -0
@@ -606,6 +616,12 @@ static int dwcmshc_suspend(struct device *dev)
        if (ret)
                return ret;
 

sdhci_suspend_host() is called a few lines above, which requires the host to be runtime resumed when called. This may not be the case here.

To fix this there are in principle two options:

1) Call a pm_runtime_get_sync() around here and a corresponding pm_runtime_put_noidle() somewhere after you have called pm_runtime_force_suspend().

2) Move away from using sdhci_suspend|resume_host(), but use sdhci_runtime_suspend|resume_host() instead. This requires some additional changes, but with the benefit that we can avoid runtime resuming the device upfront. In this case, sdhci_runtime_suspend|resume_host() should be called from dwcmshc_runtime_suspend|resume(). Moreover, we either need to move the entire clock mgmt from dwcmshc_suspend|resume() into the dwcmshc_runtime_suspend|resume() or call pm_runtime_get_noresume() before calling pm_runtime_force_suspend() and pm_runtime_put_noidle() just after it.

Quoted 67 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +52 -1
+       ret = pm_runtime_force_suspend(dev);
+       if (ret) {
+               sdhci_resume_host(host);
+               return ret;
+       }
+
        clk_disable_unprepare(pltfm_host->clk);
        if (!IS_ERR(priv->bus_clk))
                clk_disable_unprepare(priv->bus_clk);
@@ -625,6 +641,10 @@ static int dwcmshc_resume(struct device *dev)
        struct rk35xx_priv *rk_priv = priv->priv;
        int ret;
 
+       ret = pm_runtime_force_resume(dev);
+       if (ret)
+               return ret;
+
        ret = clk_prepare_enable(pltfm_host->clk);
        if (ret)
                return ret;
@@ -646,7 +666,55 @@ static int dwcmshc_resume(struct device *dev)
 }
 #endif
 
-static SIMPLE_DEV_PM_OPS(dwcmshc_pmops, dwcmshc_suspend, dwcmshc_resume);
+#ifdef CONFIG_PM
+
+static void dwcmshc_enable_card_clk(struct sdhci_host *host)
+{
+       u16 ctrl;
+
+       ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+       if ((ctrl & SDHCI_CLOCK_INT_EN) && !(ctrl & SDHCI_CLOCK_CARD_EN)) {
+               ctrl |= SDHCI_CLOCK_CARD_EN;
+               sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+       }
+}
+
+static void dwcmshc_disable_card_clk(struct sdhci_host *host)
+{
+       u16 ctrl;
+
+       ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+       if (ctrl & SDHCI_CLOCK_CARD_EN) {
+               ctrl &= ~SDHCI_CLOCK_CARD_EN;
+               sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+       }
+}
+
+static int dwcmshc_runtime_suspend(struct device *dev)
+{
+       struct sdhci_host *host = dev_get_drvdata(dev);
+
+       dwcmshc_disable_card_clk(host);
+
+       return 0;
+}
+
+static int dwcmshc_runtime_resume(struct device *dev)
+{
+       struct sdhci_host *host = dev_get_drvdata(dev);
+
+       dwcmshc_enable_card_clk(host);
+
+       return 0;
+}
+

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 720

Quoted 10 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +7 -0
+#endif
+
+static const struct dev_pm_ops dwcmshc_pmops = {
+       SET_SYSTEM_SLEEP_PM_OPS(dwcmshc_suspend, dwcmshc_resume)
+       SET_RUNTIME_PM_OPS(dwcmshc_runtime_suspend,
+                          dwcmshc_runtime_resume, NULL)
+};
 
 static struct platform_driver sdhci_dwcmshc_driver = {
        .driver = {

Kind regards
Uffe

author
#18 lore raw

PATCH v7 1/1 mmc: sdhci-of-dwcmshc: Add runtime PM operations

In reply to Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v6->v7:
- Address Ulf's comment;
v5->v6:
- Address Adrian's more comments and add coordination between runtime PM and system PM;
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 72 ++++++++++++++++++++++++++++-
 1 file changed, 70 insertions(+), 2 deletions(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +70 -2
index e68cd87998c8..c8e145031429 100644
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -548,9 +549,13 @@ static int dwcmshc_probe(struct platform_device *pdev)
 
 	host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
+	pm_runtime_get_noresume(dev);
+	pm_runtime_set_active(dev);
+	pm_runtime_enable(dev);
+
 	err = sdhci_setup_host(host);
 	if (err)
-		goto err_clk;
+		goto err_rpm;
 
 	if (rk_priv)
 		dwcmshc_rk35xx_postinit(host, priv);
@@ -559,10 +564,15 @@ static int dwcmshc_probe(struct platform_device *pdev)
 	if (err)
 		goto err_setup_host;
 
+	pm_runtime_put(dev);
+
 	return 0;
 
 err_setup_host:
 	sdhci_cleanup_host(host);
+err_rpm:
+	pm_runtime_disable(dev);
+	pm_runtime_put_noidle(dev);
 err_clk:
 	clk_disable_unprepare(pltfm_host->clk);
 	clk_disable_unprepare(priv->bus_clk);
@@ -606,6 +616,12 @@ static int dwcmshc_suspend(struct device *dev)
 	if (ret)
 		return ret;
 
+	ret = pm_runtime_force_suspend(dev);
+	if (ret) {
+		sdhci_resume_host(host);
+		return ret;
+	}
+
 	clk_disable_unprepare(pltfm_host->clk);
 	if (!IS_ERR(priv->bus_clk))
 		clk_disable_unprepare(priv->bus_clk);
@@ -625,6 +641,10 @@ static int dwcmshc_resume(struct device *dev)
 	struct rk35xx_priv *rk_priv = priv->priv;
 	int ret;
 
+	ret = pm_runtime_force_resume(dev);
+	if (ret)
+		return ret;
+
 	ret = clk_prepare_enable(pltfm_host->clk);
 	if (ret)
 		return ret;
@@ -646,7 +666,55 @@ static int dwcmshc_resume(struct device *dev)
 }
 #endif
 
-static SIMPLE_DEV_PM_OPS(dwcmshc_pmops, dwcmshc_suspend, dwcmshc_resume);
+#ifdef CONFIG_PM
+
+static void dwcmshc_enable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	if ((ctrl & SDHCI_CLOCK_INT_EN) && !(ctrl & SDHCI_CLOCK_CARD_EN)) {
+		ctrl |= SDHCI_CLOCK_CARD_EN;
+		sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+	}
+}
+
+static void dwcmshc_disable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	if (ctrl & SDHCI_CLOCK_CARD_EN) {
+		ctrl &= ~SDHCI_CLOCK_CARD_EN;
+		sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+	}
+}
+
+static int dwcmshc_runtime_suspend(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+
+	dwcmshc_disable_card_clk(host);
+
+	return 0;
+}
+
+static int dwcmshc_runtime_resume(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+
+	dwcmshc_enable_card_clk(host);
+
+	return 0;
+}
+
+#endif
+
+static const struct dev_pm_ops dwcmshc_pmops = {
+	SET_SYSTEM_SLEEP_PM_OPS(dwcmshc_suspend, dwcmshc_resume)
+	SET_RUNTIME_PM_OPS(dwcmshc_runtime_suspend,
+			   dwcmshc_runtime_resume, NULL)
+};
 
 static struct platform_driver sdhci_dwcmshc_driver = {
 	.driver	= {
Signature · 1 line
2.30.1
maintainer
#19 lore raw

Re: [PATCH v7] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 70 lines · Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v6->v7:
- Address Ulf's comment;
v5->v6:
- Address Adrian's more comments and add coordination between runtime PM and system PM;
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 72 ++++++++++++++++++++++++++++-
 1 file changed, 70 insertions(+), 2 deletions(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +11 -1
index e68cd87998c8..c8e145031429 100644
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -548,9 +549,13 @@ static int dwcmshc_probe(struct platform_device *pdev)
 
 	host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
+	pm_runtime_get_noresume(dev);
+	pm_runtime_set_active(dev);
+	pm_runtime_enable(dev);
+
 	err = sdhci_setup_host(host);
 	if (err)
-		goto err_clk;
+		goto err_rpm;
 
 	if (rk_priv)
 		dwcmshc_rk35xx_postinit(host, priv);
@@ -559,10 +564,15 @@ static int dwcmshc_probe(struct platform_device *pdev)
 	if (err)
 		goto err_setup_host;
 
+	pm_runtime_put(dev);
+
 	return 0;
 
 err_setup_host:
 	sdhci_cleanup_host(host);
+err_rpm:
+	pm_runtime_disable(dev);
+	pm_runtime_put_noidle(dev);
 err_clk:
 	clk_disable_unprepare(pltfm_host->clk);
 	clk_disable_unprepare(priv->bus_clk);

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_suspend(struct device *dev) · line 623

Quoted 8 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +5 -0
@@ -606,6 +616,12 @@ static int dwcmshc_suspend(struct device *dev)
 	if (ret)
 		return ret;
 
+	ret = pm_runtime_force_suspend(dev);
+	if (ret) {
+		sdhci_resume_host(host);
+		return ret;
+	}

Since you are only using the runtime PM callbacks to turn off the card clock via SDHCI_CLOCK_CONTROL, pm_runtime_force_suspend() and pm_runtime_force_resume() are not needed at all.

sdhci_suspend_host() does not care if SDHCI_CLOCK_CARD_EN is on or off. (And you are disabling pltfm_host->clk and priv->bus_clk, so presumably the result is no clock either way)

sdhci_resume_host() does not restore state unless SDHCI_QUIRK2_HOST_OFF_CARD_ON is used, it just resets, so the internal clock SDHCI_CLOCK_INT_EN is off which is consistent with either runtime suspended or runtime resumed.

So it just needs some comments, for example:

+/*
+ * Note, runtime suspend changes only SDHCI_CLOCK_CARD_EN which has no effect on
+ * system suspend.
+ */
static int dwcmshc_suspend(struct device *dev)

+/*
+ * Note, system resume leaves SDHCI_CLOCK_INT_EN off which is consistent with
+ * either runtime suspended or runtime resumed.
+ */
static int dwcmshc_resume(struct device *dev)

Quoted 72 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +54 -1
+
 	clk_disable_unprepare(pltfm_host->clk);
 	if (!IS_ERR(priv->bus_clk))
 		clk_disable_unprepare(priv->bus_clk);
@@ -625,6 +641,10 @@ static int dwcmshc_resume(struct device *dev)
 	struct rk35xx_priv *rk_priv = priv->priv;
 	int ret;
 
+	ret = pm_runtime_force_resume(dev);
+	if (ret)
+		return ret;
+
 	ret = clk_prepare_enable(pltfm_host->clk);
 	if (ret)
 		return ret;
@@ -646,7 +666,55 @@ static int dwcmshc_resume(struct device *dev)
 }
 #endif
 
-static SIMPLE_DEV_PM_OPS(dwcmshc_pmops, dwcmshc_suspend, dwcmshc_resume);
+#ifdef CONFIG_PM
+
+static void dwcmshc_enable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	if ((ctrl & SDHCI_CLOCK_INT_EN) && !(ctrl & SDHCI_CLOCK_CARD_EN)) {
+		ctrl |= SDHCI_CLOCK_CARD_EN;
+		sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+	}
+}
+
+static void dwcmshc_disable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	if (ctrl & SDHCI_CLOCK_CARD_EN) {
+		ctrl &= ~SDHCI_CLOCK_CARD_EN;
+		sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+	}
+}
+
+static int dwcmshc_runtime_suspend(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+
+	dwcmshc_disable_card_clk(host);
+
+	return 0;
+}
+
+static int dwcmshc_runtime_resume(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+
+	dwcmshc_enable_card_clk(host);
+
+	return 0;
+}
+
+#endif
+
+static const struct dev_pm_ops dwcmshc_pmops = {
+	SET_SYSTEM_SLEEP_PM_OPS(dwcmshc_suspend, dwcmshc_resume)
+	SET_RUNTIME_PM_OPS(dwcmshc_runtime_suspend,
+			   dwcmshc_runtime_resume, NULL)
+};
 
 static struct platform_driver sdhci_dwcmshc_driver = {
 	.driver	= {
#20 lore raw

Re: [PATCH v7] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 75 lines · Adrian Hunter
Quoted 73 lines · Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v6->v7:
- Address Ulf's comment;
v5->v6:
- Address Adrian's more comments and add coordination between runtime PM and system PM;
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 72 ++++++++++++++++++++++++++++-
 1 file changed, 70 insertions(+), 2 deletions(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +11 -1
index e68cd87998c8..c8e145031429 100644
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -548,9 +549,13 @@ static int dwcmshc_probe(struct platform_device *pdev)
 
      host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
+     pm_runtime_get_noresume(dev);
+     pm_runtime_set_active(dev);
+     pm_runtime_enable(dev);
+
      err = sdhci_setup_host(host);
      if (err)
-             goto err_clk;
+             goto err_rpm;
 
      if (rk_priv)
              dwcmshc_rk35xx_postinit(host, priv);
@@ -559,10 +564,15 @@ static int dwcmshc_probe(struct platform_device *pdev)
      if (err)
              goto err_setup_host;
 
+     pm_runtime_put(dev);
+
      return 0;
 
 err_setup_host:
      sdhci_cleanup_host(host);
+err_rpm:
+     pm_runtime_disable(dev);
+     pm_runtime_put_noidle(dev);
 err_clk:
      clk_disable_unprepare(pltfm_host->clk);
      clk_disable_unprepare(priv->bus_clk);
@@ -606,6 +616,12 @@ static int dwcmshc_suspend(struct device *dev)
      if (ret)
              return ret;
 
Quoted 9 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_suspend(struct device *dev) · line 623

Quoted 5 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +5 -0
+     ret = pm_runtime_force_suspend(dev);
+     if (ret) {
+             sdhci_resume_host(host);
+             return ret;
+     }

Since you are only using the runtime PM callbacks to turn off the card clock via SDHCI_CLOCK_CONTROL, pm_runtime_force_suspend() and pm_runtime_force_resume() are not needed at all.

Right, it can be done without these too.

Quoted 9 lines

sdhci_suspend_host() does not care if SDHCI_CLOCK_CARD_EN is on or off. (And you are disabling pltfm_host->clk and priv->bus_clk, so presumably the result is no clock either way)

sdhci_resume_host() does not restore state unless SDHCI_QUIRK2_HOST_OFF_CARD_ON is used, it just resets, so the internal clock SDHCI_CLOCK_INT_EN is off which is consistent with either runtime suspended or runtime resumed.

Even if this may work, to me, it doesn't look like good practice for how to use runtime PM in combination with system wide suspend/resume.

The point is, sdhci_suspend|resume_host() may end up reading/writing to sdhci registers - and we should *not* allow that (because it may not always work), unless the sdhci controller has been runtime resumed first, right?

[...]

Kind regards
Uffe

maintainer
#21 lore raw

Re: [PATCH v7] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 98 lines · Ulf Hansson
Quoted 75 lines · Adrian Hunter
Quoted 73 lines · Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v6->v7:
- Address Ulf's comment;
v5->v6:
- Address Adrian's more comments and add coordination between runtime PM and system PM;
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 72 ++++++++++++++++++++++++++++-
 1 file changed, 70 insertions(+), 2 deletions(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +11 -1
index e68cd87998c8..c8e145031429 100644
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -548,9 +549,13 @@ static int dwcmshc_probe(struct platform_device *pdev)
 
      host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
+     pm_runtime_get_noresume(dev);
+     pm_runtime_set_active(dev);
+     pm_runtime_enable(dev);
+
      err = sdhci_setup_host(host);
      if (err)
-             goto err_clk;
+             goto err_rpm;
 
      if (rk_priv)
              dwcmshc_rk35xx_postinit(host, priv);
@@ -559,10 +564,15 @@ static int dwcmshc_probe(struct platform_device *pdev)
      if (err)
              goto err_setup_host;
 
+     pm_runtime_put(dev);
+
      return 0;
 
 err_setup_host:
      sdhci_cleanup_host(host);
+err_rpm:
+     pm_runtime_disable(dev);
+     pm_runtime_put_noidle(dev);
 err_clk:
      clk_disable_unprepare(pltfm_host->clk);
      clk_disable_unprepare(priv->bus_clk);
@@ -606,6 +616,12 @@ static int dwcmshc_suspend(struct device *dev)
      if (ret)
              return ret;
 
Quoted 9 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_suspend(struct device *dev) · line 623

Quoted 5 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +5 -0
+     ret = pm_runtime_force_suspend(dev);
+     if (ret) {
+             sdhci_resume_host(host);
+             return ret;
+     }

Since you are only using the runtime PM callbacks to turn off the card clock via SDHCI_CLOCK_CONTROL, pm_runtime_force_suspend() and pm_runtime_force_resume() are not needed at all.

Right, it can be done without these too.

Quoted 9 lines

sdhci_suspend_host() does not care if SDHCI_CLOCK_CARD_EN is on or off. (And you are disabling pltfm_host->clk and priv->bus_clk, so presumably the result is no clock either way)

sdhci_resume_host() does not restore state unless SDHCI_QUIRK2_HOST_OFF_CARD_ON is used, it just resets, so the internal clock SDHCI_CLOCK_INT_EN is off which is consistent with either runtime suspended or runtime resumed.

Quoted 7 lines

Even if this may work, to me, it doesn't look like good practice for how to use runtime PM in combination with system wide suspend/resume.

The point is, sdhci_suspend|resume_host() may end up reading/writing to sdhci registers - and we should *not* allow that (because it may not always work), unless the sdhci controller has been runtime resumed first, right?

I am OK with drivers that just want to use runtime PM to turn off a functional clock. sdhci-tegra.c is also doing that although using the clock framework.

Certainly that approach assumes that the host controller's power state is not changed due to runtime PM.

To ensure that the host controller is runtime resumed before calling sdhci_suspend_host(), we can just call pm_runtime_resume() I think.

#22 lore raw

Re: [PATCH v7] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 103 lines · Adrian Hunter
Quoted 101 lines · Ulf Hansson
Quoted 75 lines · Adrian Hunter
Quoted 73 lines · Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v6->v7:
- Address Ulf's comment;
v5->v6:
- Address Adrian's more comments and add coordination between runtime PM and system PM;
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 72 ++++++++++++++++++++++++++++-
 1 file changed, 70 insertions(+), 2 deletions(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +11 -1
index e68cd87998c8..c8e145031429 100644
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -548,9 +549,13 @@ static int dwcmshc_probe(struct platform_device *pdev)
 
      host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
+     pm_runtime_get_noresume(dev);
+     pm_runtime_set_active(dev);
+     pm_runtime_enable(dev);
+
      err = sdhci_setup_host(host);
      if (err)
-             goto err_clk;
+             goto err_rpm;
 
      if (rk_priv)
              dwcmshc_rk35xx_postinit(host, priv);
@@ -559,10 +564,15 @@ static int dwcmshc_probe(struct platform_device *pdev)
      if (err)
              goto err_setup_host;
 
+     pm_runtime_put(dev);
+
      return 0;
 
 err_setup_host:
      sdhci_cleanup_host(host);
+err_rpm:
+     pm_runtime_disable(dev);
+     pm_runtime_put_noidle(dev);
 err_clk:
      clk_disable_unprepare(pltfm_host->clk);
      clk_disable_unprepare(priv->bus_clk);
@@ -606,6 +616,12 @@ static int dwcmshc_suspend(struct device *dev)
      if (ret)
              return ret;
 
Quoted 9 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_suspend(struct device *dev) · line 623

Quoted 5 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +5 -0
+     ret = pm_runtime_force_suspend(dev);
+     if (ret) {
+             sdhci_resume_host(host);
+             return ret;
+     }

Since you are only using the runtime PM callbacks to turn off the card clock via SDHCI_CLOCK_CONTROL, pm_runtime_force_suspend() and pm_runtime_force_resume() are not needed at all.

Right, it can be done without these too.

Quoted 9 lines

sdhci_suspend_host() does not care if SDHCI_CLOCK_CARD_EN is on or off. (And you are disabling pltfm_host->clk and priv->bus_clk, so presumably the result is no clock either way)

sdhci_resume_host() does not restore state unless SDHCI_QUIRK2_HOST_OFF_CARD_ON is used, it just resets, so the internal clock SDHCI_CLOCK_INT_EN is off which is consistent with either runtime suspended or runtime resumed.

Even if this may work, to me, it doesn't look like good practice for how to use runtime PM in combination with system wide suspend/resume.

Quoted 8 lines
Quoted 4 lines

The point is, sdhci_suspend|resume_host() may end up reading/writing to sdhci registers - and we should *not* allow that (because it may not always work), unless the sdhci controller has been runtime resumed first, right?

I am OK with drivers that just want to use runtime PM to turn off a functional clock. sdhci-tegra.c is also doing that although using the clock framework.

Yes, I agree. At least this works for SoC specific drivers.

Quoted 6 lines

Certainly that approach assumes that the host controller's power state is not changed due to runtime PM.

To ensure that the host controller is runtime resumed before calling sdhci_suspend_host(), we can just call pm_runtime_resume() I think.

Yes, that was kind of what I proposed in the other thread as option 1) (except for the replacement of pm_runtime_force_suspend|resume).

Although, to be clear I would probably use pm_runtime_get_sync() instead, to make sure the usage count is incremented too.

I don't have a strong opinion here, but from an optimization point of view I would at least consider what I proposed in option 2) (in the other thread). The benefit is that it can allow us to potentially avoid runtime resuming the device, during system suspend.

Kind regards
Uffe

maintainer
#23 lore raw

Re: [PATCH v7] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 119 lines · Ulf Hansson
Quoted 103 lines · Adrian Hunter
Quoted 101 lines · Ulf Hansson
Quoted 75 lines · Adrian Hunter
Quoted 73 lines · Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v6->v7:
- Address Ulf's comment;
v5->v6:
- Address Adrian's more comments and add coordination between runtime PM and system PM;
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 72 ++++++++++++++++++++++++++++-
 1 file changed, 70 insertions(+), 2 deletions(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +11 -1
index e68cd87998c8..c8e145031429 100644
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -548,9 +549,13 @@ static int dwcmshc_probe(struct platform_device *pdev)
 
      host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
+     pm_runtime_get_noresume(dev);
+     pm_runtime_set_active(dev);
+     pm_runtime_enable(dev);
+
      err = sdhci_setup_host(host);
      if (err)
-             goto err_clk;
+             goto err_rpm;
 
      if (rk_priv)
              dwcmshc_rk35xx_postinit(host, priv);
@@ -559,10 +564,15 @@ static int dwcmshc_probe(struct platform_device *pdev)
      if (err)
              goto err_setup_host;
 
+     pm_runtime_put(dev);
+
      return 0;
 
 err_setup_host:
      sdhci_cleanup_host(host);
+err_rpm:
+     pm_runtime_disable(dev);
+     pm_runtime_put_noidle(dev);
 err_clk:
      clk_disable_unprepare(pltfm_host->clk);
      clk_disable_unprepare(priv->bus_clk);
@@ -606,6 +616,12 @@ static int dwcmshc_suspend(struct device *dev)
      if (ret)
              return ret;
 
Quoted 9 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_suspend(struct device *dev) · line 623

Quoted 5 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +5 -0
+     ret = pm_runtime_force_suspend(dev);
+     if (ret) {
+             sdhci_resume_host(host);
+             return ret;
+     }

Since you are only using the runtime PM callbacks to turn off the card clock via SDHCI_CLOCK_CONTROL, pm_runtime_force_suspend() and pm_runtime_force_resume() are not needed at all.

Right, it can be done without these too.

Quoted 9 lines

sdhci_suspend_host() does not care if SDHCI_CLOCK_CARD_EN is on or off. (And you are disabling pltfm_host->clk and priv->bus_clk, so presumably the result is no clock either way)

sdhci_resume_host() does not restore state unless SDHCI_QUIRK2_HOST_OFF_CARD_ON is used, it just resets, so the internal clock SDHCI_CLOCK_INT_EN is off which is consistent with either runtime suspended or runtime resumed.

Even if this may work, to me, it doesn't look like good practice for how to use runtime PM in combination with system wide suspend/resume.

Quoted 8 lines
Quoted 4 lines

The point is, sdhci_suspend|resume_host() may end up reading/writing to sdhci registers - and we should *not* allow that (because it may not always work), unless the sdhci controller has been runtime resumed first, right?

I am OK with drivers that just want to use runtime PM to turn off a functional clock. sdhci-tegra.c is also doing that although using the clock framework.

Yes, I agree. At least this works for SoC specific drivers.

Quoted 4 lines

Certainly that approach assumes that the host controller's power state is not changed due to runtime PM.

Quoted 8 lines
Quoted 2 lines

To ensure that the host controller is runtime resumed before calling sdhci_suspend_host(), we can just call pm_runtime_resume() I think.

Yes, that was kind of what I proposed in the other thread as option 1) (except for the replacement of pm_runtime_force_suspend|resume).

Although, to be clear I would probably use pm_runtime_get_sync() instead, to make sure the usage count is incremented too.

In that case, a matching pm_runtime_put() is needed also at the end of the resume callback.

Quoted 8 lines

I don't have a strong opinion here, but from an optimization point of view I would at least consider what I proposed in option 2) (in the other thread). The benefit is that it can allow us to potentially avoid runtime resuming the device, during system suspend.

Kind regards
Uffe

#24 lore raw

Re: [PATCH v7] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 124 lines · Adrian Hunter
Quoted 122 lines · Ulf Hansson
Quoted 103 lines · Adrian Hunter
Quoted 101 lines · Ulf Hansson
Quoted 75 lines · Adrian Hunter
Quoted 73 lines · Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v6->v7:
- Address Ulf's comment;
v5->v6:
- Address Adrian's more comments and add coordination between runtime PM and system PM;
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 72 ++++++++++++++++++++++++++++-
 1 file changed, 70 insertions(+), 2 deletions(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +11 -1
index e68cd87998c8..c8e145031429 100644
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -548,9 +549,13 @@ static int dwcmshc_probe(struct platform_device *pdev)
 
      host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
+     pm_runtime_get_noresume(dev);
+     pm_runtime_set_active(dev);
+     pm_runtime_enable(dev);
+
      err = sdhci_setup_host(host);
      if (err)
-             goto err_clk;
+             goto err_rpm;
 
      if (rk_priv)
              dwcmshc_rk35xx_postinit(host, priv);
@@ -559,10 +564,15 @@ static int dwcmshc_probe(struct platform_device *pdev)
      if (err)
              goto err_setup_host;
 
+     pm_runtime_put(dev);
+
      return 0;
 
 err_setup_host:
      sdhci_cleanup_host(host);
+err_rpm:
+     pm_runtime_disable(dev);
+     pm_runtime_put_noidle(dev);
 err_clk:
      clk_disable_unprepare(pltfm_host->clk);
      clk_disable_unprepare(priv->bus_clk);
@@ -606,6 +616,12 @@ static int dwcmshc_suspend(struct device *dev)
      if (ret)
              return ret;
 
Quoted 9 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_suspend(struct device *dev) · line 623

Quoted 5 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +5 -0
+     ret = pm_runtime_force_suspend(dev);
+     if (ret) {
+             sdhci_resume_host(host);
+             return ret;
+     }

Since you are only using the runtime PM callbacks to turn off the card clock via SDHCI_CLOCK_CONTROL, pm_runtime_force_suspend() and pm_runtime_force_resume() are not needed at all.

Right, it can be done without these too.

Quoted 9 lines

sdhci_suspend_host() does not care if SDHCI_CLOCK_CARD_EN is on or off. (And you are disabling pltfm_host->clk and priv->bus_clk, so presumably the result is no clock either way)

sdhci_resume_host() does not restore state unless SDHCI_QUIRK2_HOST_OFF_CARD_ON is used, it just resets, so the internal clock SDHCI_CLOCK_INT_EN is off which is consistent with either runtime suspended or runtime resumed.

Even if this may work, to me, it doesn't look like good practice for how to use runtime PM in combination with system wide suspend/resume.

Quoted 8 lines
Quoted 4 lines

The point is, sdhci_suspend|resume_host() may end up reading/writing to sdhci registers - and we should *not* allow that (because it may not always work), unless the sdhci controller has been runtime resumed first, right?

I am OK with drivers that just want to use runtime PM to turn off a functional clock. sdhci-tegra.c is also doing that although using the clock framework.

Yes, I agree. At least this works for SoC specific drivers.

Quoted 6 lines

Certainly that approach assumes that the host controller's power state is not changed due to runtime PM.

To ensure that the host controller is runtime resumed before calling sdhci_suspend_host(), we can just call pm_runtime_resume() I think.

Quoted 8 lines
Quoted 5 lines

Yes, that was kind of what I proposed in the other thread as option 1) (except for the replacement of pm_runtime_force_suspend|resume).

Although, to be clear I would probably use pm_runtime_get_sync() instead, to make sure the usage count is incremented too.

In that case, a matching pm_runtime_put() is needed also at the end of the resume callback.

Yes, of course. Or depending if we are using the force_suspend|resume helper, a pm_runtime_put_noidle is sufficient after pm_runtime_force_suspend() has been called.

[...]

Kind regards
Uffe

author
#25 lore raw

RE: [PATCH v7] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 155 lines

-----Original Message-----
From: Ulf Hansson <[email protected]>
Sent: Friday, August 11, 2023 4:36 AM
To: Adrian Hunter <[email protected]>
Cc: Liming Sun <[email protected]>; David Thompson <[email protected]>; Shawn Lin <[email protected]>; linux- [email protected]; [email protected]
Subject: Re: [PATCH v7] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 3 lines · Adrian Hunter
Quoted 1 line · Ulf Hansson

On Thu, 10 Aug 2023 at 14:44, Adrian Hunter <[email protected]>

Quoted 3 lines · wrote:
Quoted 3 lines
Quoted 3 lines · Ulf Hansson
Quoted 1 line

On Thu, 10 Aug 2023 at 10:13, Adrian Hunter

Quoted 18 lines · <[email protected]> wrote:
Quoted 18 lines
Quoted 18 lines
Quoted 18 lines
Quoted 18 lines · Liming Sun
Quoted 16 lines

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v6->v7:
- Address Ulf's comment;
v5->v6:
- Address Adrian's more comments and add coordination between runtime PM and system PM;
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 72

++++++++++++++++++++++++++++-

Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines

Review

Quoted 3 lines
 1 file changed, 70 insertions(+), 2 deletions(-)
(quoted diff) +0 -0

b/drivers/mmc/host/sdhci-of-dwcmshc.c

Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines

index e68cd87998c8..c8e145031429 100644

drivers/mmc/host/sdhci-of-dwcmshc.c +1 -0
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_probe(struct

Quoted 1 line
drivers/mmc/host/sdhci-of-dwcmshc.c +0 -0
@@ -548,9 +549,13 @@ static int dwcmshc_probe(struct

platform_device *pdev)

Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +5 -1
      host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
+     pm_runtime_get_noresume(dev);
+     pm_runtime_set_active(dev);
+     pm_runtime_enable(dev);
+
      err = sdhci_setup_host(host);
      if (err)
-             goto err_clk;
+             goto err_rpm;
 
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_probe(struct

Quoted 3 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +0 -0
      if (rk_priv)
              dwcmshc_rk35xx_postinit(host, priv);
@@ -559,10 +564,15 @@ static int dwcmshc_probe(struct

platform_device *pdev)

Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +2 -0
      if (err)
              goto err_setup_host;
 
+     pm_runtime_put(dev);
+
      return 0;
 
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_suspend(struct device

Quoted 9 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +3 -0
 err_setup_host:
      sdhci_cleanup_host(host);
+err_rpm:
+     pm_runtime_disable(dev);
+     pm_runtime_put_noidle(dev);
 err_clk:
      clk_disable_unprepare(pltfm_host->clk);
      clk_disable_unprepare(priv->bus_clk);
@@ -606,6 +616,12 @@ static int dwcmshc_suspend(struct device

*dev)

Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 8 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +5 -0
      if (ret)
              return ret;
 
+     ret = pm_runtime_force_suspend(dev);
+     if (ret) {
+             sdhci_resume_host(host);
+             return ret;
+     }
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 3 lines

Since you are only using the runtime PM callbacks to turn off the card clock via SDHCI_CLOCK_CONTROL, pm_runtime_force_suspend() and pm_runtime_force_resume() are not needed at all.

Right, it can be done without these too.

Quoted 2 lines

sdhci_suspend_host() does not care if SDHCI_CLOCK_CARD_EN is on or

off.

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

(And you are disabling pltfm_host->clk and priv->bus_clk, so

presumably

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines

the result is no clock either way)

sdhci_resume_host() does not restore state unless SDHCI_QUIRK2_HOST_OFF_CARD_ON is used, it just resets, so the

internal clock

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

SDHCI_CLOCK_INT_EN is off which is consistent with either runtime

suspended

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 1 line

or runtime resumed.

Even if this may work, to me, it doesn't look like good practice for how to use runtime PM in combination with system wide

suspend/resume.

Quoted 25 lines
Quoted 24 lines
Quoted 9 lines
Quoted 5 lines

The point is, sdhci_suspend|resume_host() may end up reading/writing to sdhci registers - and we should *not* allow that (because it may not always work), unless the sdhci controller has been runtime resumed first, right?

I am OK with drivers that just want to use runtime PM to turn off a functional clock. sdhci-tegra.c is also doing that although using the clock framework.

Yes, I agree. At least this works for SoC specific drivers.

Quoted 6 lines

Certainly that approach assumes that the host controller's power state is not changed due to runtime PM.

To ensure that the host controller is runtime resumed before calling sdhci_suspend_host(), we can just call pm_runtime_resume() I think.

Yes, that was kind of what I proposed in the other thread as option 1) (except for the replacement of pm_runtime_force_suspend|resume).

Although, to be clear I would probably use pm_runtime_get_sync() instead, to make sure the usage count is incremented too.

Quoted 6 lines
Quoted 2 lines

In that case, a matching pm_runtime_put() is needed also at the end of the resume callback.

Yes, of course. Or depending if we are using the force_suspend|resume helper, a pm_runtime_put_noidle is sufficient after pm_runtime_force_suspend() has been called.

Thanks Ulf/Adrian! Plan to upload v8 with the following changes:
- Remove pm_runtime_force_suspend/resume() from dwcmshc_suspend()/dwcmshc_resume() (Adrian's comment).
- Add comments for dwcmshc_resume()/dwcmshc_suspend();
(According to Andrian's comment).
- Add pm_runtime_get_sync()/pm_runtime_put() in dwcmshc_suspend(), which is Ulf option-1. Option-2 seems more efficient, but it involves more changes and I couldn't test the impact on other SoC. Maybe for future enhancement?

Quoted 5 lines

[...]

Kind regards
Uffe

#26 lore raw

Re: [PATCH v7] mmc: sdhci-of-dwcmshc: Add runtime PM operations

[...]

Quoted 56 lines
Quoted 49 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 4 lines

Since you are only using the runtime PM callbacks to turn off the card clock via SDHCI_CLOCK_CONTROL, pm_runtime_force_suspend() and pm_runtime_force_resume() are not needed at all.

Right, it can be done without these too.

Quoted 2 lines

sdhci_suspend_host() does not care if SDHCI_CLOCK_CARD_EN is on or

off.

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

(And you are disabling pltfm_host->clk and priv->bus_clk, so

presumably

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines

the result is no clock either way)

sdhci_resume_host() does not restore state unless SDHCI_QUIRK2_HOST_OFF_CARD_ON is used, it just resets, so the

internal clock

Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line

SDHCI_CLOCK_INT_EN is off which is consistent with either runtime

suspended

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 1 line

or runtime resumed.

Even if this may work, to me, it doesn't look like good practice for how to use runtime PM in combination with system wide

suspend/resume.

Quoted 25 lines
Quoted 24 lines
Quoted 9 lines
Quoted 5 lines

The point is, sdhci_suspend|resume_host() may end up reading/writing to sdhci registers - and we should *not* allow that (because it may not always work), unless the sdhci controller has been runtime resumed first, right?

I am OK with drivers that just want to use runtime PM to turn off a functional clock. sdhci-tegra.c is also doing that although using the clock framework.

Yes, I agree. At least this works for SoC specific drivers.

Quoted 6 lines

Certainly that approach assumes that the host controller's power state is not changed due to runtime PM.

To ensure that the host controller is runtime resumed before calling sdhci_suspend_host(), we can just call pm_runtime_resume() I think.

Yes, that was kind of what I proposed in the other thread as option 1) (except for the replacement of pm_runtime_force_suspend|resume).

Although, to be clear I would probably use pm_runtime_get_sync() instead, to make sure the usage count is incremented too.

Quoted 6 lines
Quoted 2 lines

In that case, a matching pm_runtime_put() is needed also at the end of the resume callback.

Yes, of course. Or depending if we are using the force_suspend|resume helper, a pm_runtime_put_noidle is sufficient after pm_runtime_force_suspend() has been called.

Quoted 5 lines

Thanks Ulf/Adrian! Plan to upload v8 with the following changes:
- Remove pm_runtime_force_suspend/resume() from dwcmshc_suspend()/dwcmshc_resume() (Adrian's comment).
- Add comments for dwcmshc_resume()/dwcmshc_suspend();
(According to Andrian's comment).
- Add pm_runtime_get_sync()/pm_runtime_put() in dwcmshc_suspend(), which is Ulf option-1. Option-2 seems more efficient, but it involves more changes and I couldn't test the impact on other SoC. Maybe for future enhancement?

That works for me!

Kind regards
Uffe

author
#27 lore raw

PATCH v8 1/1 mmc: sdhci-of-dwcmshc: Add runtime PM operations

In reply to Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v7->v8:
- Address Ulf's comment (option-1);
- Updates for Adrian;s comment to remove the force_suspend/resume in dwcmshc_resume()/dwcmshc_suspend(); Add comments for dwcmshc_resume()/dwcmshc_suspend();
v6->v7:
- Address Ulf's comment;
v5->v6:
- Address Adrian's more comments and add coordination between runtime PM and system PM;
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 76 +++++++++++++++++++++++++++--
 1 file changed, 73 insertions(+), 3 deletions(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +73 -3
index e68cd87998c8..2196218c9d79 100644
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -548,9 +549,13 @@ static int dwcmshc_probe(struct platform_device *pdev)
 
 	host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
+	pm_runtime_get_noresume(dev);
+	pm_runtime_set_active(dev);
+	pm_runtime_enable(dev);
+
 	err = sdhci_setup_host(host);
 	if (err)
-		goto err_clk;
+		goto err_rpm;
 
 	if (rk_priv)
 		dwcmshc_rk35xx_postinit(host, priv);
@@ -559,10 +564,15 @@ static int dwcmshc_probe(struct platform_device *pdev)
 	if (err)
 		goto err_setup_host;
 
+	pm_runtime_put(dev);
+
 	return 0;
 
 err_setup_host:
 	sdhci_cleanup_host(host);
+err_rpm:
+	pm_runtime_disable(dev);
+	pm_runtime_put_noidle(dev);
 err_clk:
 	clk_disable_unprepare(pltfm_host->clk);
 	clk_disable_unprepare(priv->bus_clk);
@@ -594,6 +604,10 @@ static int dwcmshc_remove(struct platform_device *pdev)
 }
 
 #ifdef CONFIG_PM_SLEEP
+/*
+ * Note, runtime suspend changes only SDHCI_CLOCK_CARD_EN which has no effect on
+ * system suspend.
+ */
 static int dwcmshc_suspend(struct device *dev)
 {
 	struct sdhci_host *host = dev_get_drvdata(dev);
@@ -602,9 +616,11 @@ static int dwcmshc_suspend(struct device *dev)
 	struct rk35xx_priv *rk_priv = priv->priv;
 	int ret;
 
+	pm_runtime_get_sync(dev);
+
 	ret = sdhci_suspend_host(host);
 	if (ret)
-		return ret;
+		goto err_suspend;
 
 	clk_disable_unprepare(pltfm_host->clk);
 	if (!IS_ERR(priv->bus_clk))
@@ -614,9 +630,15 @@ static int dwcmshc_suspend(struct device *dev)
 		clk_bulk_disable_unprepare(RK35xx_MAX_CLKS,
 					   rk_priv->rockchip_clks);
 
+err_suspend:
+	pm_runtime_put_noidle(dev);
 	return ret;
 }
 
+/*
+ * Note, system resume leaves SDHCI_CLOCK_INT_EN off which is consistent with
+ * either runtime suspended or runtime resumed.
+ */
 static int dwcmshc_resume(struct device *dev)
 {
 	struct sdhci_host *host = dev_get_drvdata(dev);
@@ -646,7 +668,55 @@ static int dwcmshc_resume(struct device *dev)
 }
 #endif
 
-static SIMPLE_DEV_PM_OPS(dwcmshc_pmops, dwcmshc_suspend, dwcmshc_resume);
+#ifdef CONFIG_PM
+
+static void dwcmshc_enable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	if ((ctrl & SDHCI_CLOCK_INT_EN) && !(ctrl & SDHCI_CLOCK_CARD_EN)) {
+		ctrl |= SDHCI_CLOCK_CARD_EN;
+		sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+	}
+}
+
+static void dwcmshc_disable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	if (ctrl & SDHCI_CLOCK_CARD_EN) {
+		ctrl &= ~SDHCI_CLOCK_CARD_EN;
+		sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+	}
+}
+
+static int dwcmshc_runtime_suspend(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+
+	dwcmshc_disable_card_clk(host);
+
+	return 0;
+}
+
+static int dwcmshc_runtime_resume(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+
+	dwcmshc_enable_card_clk(host);
+
+	return 0;
+}
+
+#endif
+
+static const struct dev_pm_ops dwcmshc_pmops = {
+	SET_SYSTEM_SLEEP_PM_OPS(dwcmshc_suspend, dwcmshc_resume)
+	SET_RUNTIME_PM_OPS(dwcmshc_runtime_suspend,
+			   dwcmshc_runtime_resume, NULL)
+};
 
 static struct platform_driver sdhci_dwcmshc_driver = {
 	.driver	= {
Signature · 1 line
2.30.1
maintainer
#28 lore raw

Re: [PATCH v8] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 75 lines · Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v7->v8:
- Address Ulf's comment (option-1);
- Updates for Adrian;s comment to remove the force_suspend/resume in dwcmshc_resume()/dwcmshc_suspend(); Add comments for dwcmshc_resume()/dwcmshc_suspend();
v6->v7:
- Address Ulf's comment;
v5->v6:
- Address Adrian's more comments and add coordination between runtime PM and system PM;
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 76 +++++++++++++++++++++++++++--
 1 file changed, 73 insertions(+), 3 deletions(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +11 -1
index e68cd87998c8..2196218c9d79 100644
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -548,9 +549,13 @@ static int dwcmshc_probe(struct platform_device *pdev)
 
 	host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
+	pm_runtime_get_noresume(dev);
+	pm_runtime_set_active(dev);
+	pm_runtime_enable(dev);
+
 	err = sdhci_setup_host(host);
 	if (err)
-		goto err_clk;
+		goto err_rpm;
 
 	if (rk_priv)
 		dwcmshc_rk35xx_postinit(host, priv);
@@ -559,10 +564,15 @@ static int dwcmshc_probe(struct platform_device *pdev)
 	if (err)
 		goto err_setup_host;
 
+	pm_runtime_put(dev);
+
 	return 0;
 
 err_setup_host:
 	sdhci_cleanup_host(host);
+err_rpm:
+	pm_runtime_disable(dev);
+	pm_runtime_put_noidle(dev);
 err_clk:
 	clk_disable_unprepare(pltfm_host->clk);
 	clk_disable_unprepare(priv->bus_clk);

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_remove(struct platform_device *pdev) · line 610

Quoted 7 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +4 -0
@@ -594,6 +604,10 @@ static int dwcmshc_remove(struct platform_device *pdev)
 }
 
 #ifdef CONFIG_PM_SLEEP
+/*
+ * Note, runtime suspend changes only SDHCI_CLOCK_CARD_EN which has no effect on
+ * system suspend.
+ */

This comment isn't needed since pm_runtime_get_sync() will always runtime resume the device if needed.

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_suspend(struct device *dev) · line 619

Quoted 8 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +1 -0
 static int dwcmshc_suspend(struct device *dev)
 {
 	struct sdhci_host *host = dev_get_drvdata(dev);
@@ -602,9 +616,11 @@ static int dwcmshc_suspend(struct device *dev)
 	struct rk35xx_priv *rk_priv = priv->priv;
 	int ret;
 
+	pm_runtime_get_sync(dev);

This needs a corresponding pm_runtime_put() at the end of dwcmshc_resume().

Quoted 11 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +2 -1
+
 	ret = sdhci_suspend_host(host);
 	if (ret)
-		return ret;
+		goto err_suspend;
 
 	clk_disable_unprepare(pltfm_host->clk);
 	if (!IS_ERR(priv->bus_clk))
@@ -614,9 +630,15 @@ static int dwcmshc_suspend(struct device *dev)
 		clk_bulk_disable_unprepare(RK35xx_MAX_CLKS,
 					   rk_priv->rockchip_clks);

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_suspend(struct device *dev) · line 641

Quoted 10 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +6 -0
 
+err_suspend:
+	pm_runtime_put_noidle(dev);
 	return ret;
 }
 
+/*
+ * Note, system resume leaves SDHCI_CLOCK_INT_EN off which is consistent with
+ * either runtime suspended or runtime resumed.
+ */

As above, this comment isn't needed.

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_suspend(struct device *dev) · line 642

Quoted 1 line
drivers/mmc/host/sdhci-of-dwcmshc.c +0 -0
 static int dwcmshc_resume(struct device *dev)

As mentioned above, dwcmshc_resume() needs a pm_runtime_put() to balance the pm_runtime_get_sync().

Could fix up the error path too, but that should be a separate prior patch.

Probably end up looking like:

drivers/mmc/host/sdhci-of-dwcmshc.c +19 -3
index 20aa9b6327d2..c9b020b7a3f6 100644
@@ -652,17 +652,33 @@ static int dwcmshc_resume(struct device *dev)
 	if (!IS_ERR(priv->bus_clk)) {
 		ret = clk_prepare_enable(priv->bus_clk);
 		if (ret)
-			return ret;
+			goto disable_clk;
 	}
 
 	if (rk_priv) {
 		ret = clk_bulk_prepare_enable(RK35xx_MAX_CLKS,
 					      rk_priv->rockchip_clks);
 		if (ret)
-			return ret;
+			goto disable_bus_clk;
 	}
 
-	return sdhci_resume_host(host);
+	ret = sdhci_resume_host(host);
+	if (ret)
+		goto disable_rockchip_clks;
+
+	pm_runtime_put(dev);
+
+	return 0;
+
+disable_rockchip_clks:
+	if (rk_priv)
+		clk_bulk_disable_unprepare(RK35xx_MAX_CLKS, rk_priv->rockchip_clks);
+disable_bus_clk:
+	if (!IS_ERR(priv->bus_clk))
+		clk_disable_unprepare(priv->bus_clk);
+disable_clk:
+	clk_disable_unprepare(pltfm_host->clk);
+	return ret;
 }
 #endif
 
Quoted 59 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +49 -1
 {
 	struct sdhci_host *host = dev_get_drvdata(dev);
@@ -646,7 +668,55 @@ static int dwcmshc_resume(struct device *dev)
 }
 #endif
 
-static SIMPLE_DEV_PM_OPS(dwcmshc_pmops, dwcmshc_suspend, dwcmshc_resume);
+#ifdef CONFIG_PM
+
+static void dwcmshc_enable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	if ((ctrl & SDHCI_CLOCK_INT_EN) && !(ctrl & SDHCI_CLOCK_CARD_EN)) {
+		ctrl |= SDHCI_CLOCK_CARD_EN;
+		sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+	}
+}
+
+static void dwcmshc_disable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	if (ctrl & SDHCI_CLOCK_CARD_EN) {
+		ctrl &= ~SDHCI_CLOCK_CARD_EN;
+		sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+	}
+}
+
+static int dwcmshc_runtime_suspend(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+
+	dwcmshc_disable_card_clk(host);
+
+	return 0;
+}
+
+static int dwcmshc_runtime_resume(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+
+	dwcmshc_enable_card_clk(host);
+
+	return 0;
+}
+
+#endif
+
+static const struct dev_pm_ops dwcmshc_pmops = {
+	SET_SYSTEM_SLEEP_PM_OPS(dwcmshc_suspend, dwcmshc_resume)
+	SET_RUNTIME_PM_OPS(dwcmshc_runtime_suspend,
+			   dwcmshc_runtime_resume, NULL)
+};
 
 static struct platform_driver sdhci_dwcmshc_driver = {
 	.driver	= {
author
#29 lore raw

RE: [PATCH v8] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 97 lines

-----Original Message-----
From: Adrian Hunter <[email protected]>
Sent: Thursday, August 17, 2023 3:36 AM
To: Liming Sun <[email protected]>; Ulf Hansson <[email protected]>; David Thompson <[email protected]>; Shawn Lin <shawn.lin@rock- chips.com>
Cc: [email protected]; [email protected]
Subject: Re: [PATCH v8] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 27 lines · Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v7->v8:
- Address Ulf's comment (option-1);
- Updates for Adrian;s comment to remove the force_suspend/resume in dwcmshc_resume()/dwcmshc_suspend(); Add comments for dwcmshc_resume()/dwcmshc_suspend();
v6->v7:
- Address Ulf's comment;
v5->v6:
- Address Adrian's more comments and add coordination between runtime PM and system PM;
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

Quoted 2 lines
---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 76

+++++++++++++++++++++++++++--

drivers/mmc/host/sdhci-

Quoted 3 lines
 1 file changed, 73 insertions(+), 3 deletions(-)
drivers/mmc/host/sdhci- renamed from drivers/mmc/host/sdhci-of-dwcmshc.c +0 -0

of-dwcmshc.c

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_probe(struct platform_device

Quoted 12 lines

index e68cd87998c8..2196218c9d79 100644

drivers/mmc/host/sdhci-of-dwcmshc.c +1 -0
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -548,9 +549,13 @@ static int dwcmshc_probe(struct platform_device

*pdev)

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_probe(struct platform_device

Quoted 15 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +5 -1
 	host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
+	pm_runtime_get_noresume(dev);
+	pm_runtime_set_active(dev);
+	pm_runtime_enable(dev);
+
 	err = sdhci_setup_host(host);
 	if (err)
-		goto err_clk;
+		goto err_rpm;
 
 	if (rk_priv)
 		dwcmshc_rk35xx_postinit(host, priv);
@@ -559,10 +564,15 @@ static int dwcmshc_probe(struct platform_device

*pdev)

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_remove(struct platform_device

Quoted 16 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +5 -0
 	if (err)
 		goto err_setup_host;
 
+	pm_runtime_put(dev);
+
 	return 0;
 
 err_setup_host:
 	sdhci_cleanup_host(host);
+err_rpm:
+	pm_runtime_disable(dev);
+	pm_runtime_put_noidle(dev);
 err_clk:
 	clk_disable_unprepare(pltfm_host->clk);
 	clk_disable_unprepare(priv->bus_clk);
@@ -594,6 +604,10 @@ static int dwcmshc_remove(struct platform_device

*pdev)

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_remove(struct platform_device · line 608

Quoted 5 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +2 -0
 }
 
 #ifdef CONFIG_PM_SLEEP
+/*
+ * Note, runtime suspend changes only SDHCI_CLOCK_CARD_EN which has
Quoted 6 lines

no effect on

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_remove(struct platform_device · line 610

Quoted 2 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +2 -0
+ * system suspend.
+ */

This comment isn't needed since pm_runtime_get_sync() will always runtime resume the device if needed.

Updated in v9.

Quoted 8 lines
Quoted 8 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +0 -0
 static int dwcmshc_suspend(struct device *dev)
 {
 	struct sdhci_host *host = dev_get_drvdata(dev);
@@ -602,9 +616,11 @@ static int dwcmshc_suspend(struct device *dev)
 	struct rk35xx_priv *rk_priv = priv->priv;
 	int ret;
 
Quoted 4 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_suspend(struct device *dev) · line 619

Quoted 1 line
drivers/mmc/host/sdhci-of-dwcmshc.c +1 -0
+	pm_runtime_get_sync(dev);

This needs a corresponding pm_runtime_put() at the end of dwcmshc_resume().

Updated in v9.

Quoted 18 lines
Quoted 18 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +4 -1
+
 	ret = sdhci_suspend_host(host);
 	if (ret)
-		return ret;
+		goto err_suspend;
 
 	clk_disable_unprepare(pltfm_host->clk);
 	if (!IS_ERR(priv->bus_clk))
@@ -614,9 +630,15 @@ static int dwcmshc_suspend(struct device *dev)
 		clk_bulk_disable_unprepare(RK35xx_MAX_CLKS,
 					   rk_priv->rockchip_clks);
 
+err_suspend:
+	pm_runtime_put_noidle(dev);
 	return ret;
 }
 
Quoted 7 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_suspend(struct device *dev) · line 639

Quoted 2 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +2 -0
+/*
+ * Note, system resume leaves SDHCI_CLOCK_INT_EN off which is consistent

with

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_suspend(struct device *dev) · line 641

Quoted 2 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +2 -0
+ * either runtime suspended or runtime resumed.
+ */

As above, this comment isn't needed.

Updated in v9.

Quoted 6 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_suspend(struct device *dev) · line 642

Quoted 2 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +0 -0
 static int dwcmshc_resume(struct device *dev)

As mentioned above, dwcmshc_resume() needs a pm_runtime_put() to balance the pm_runtime_get_sync().

Updated in v9.

Quoted 41 lines

Could fix up the error path too, but that should be a separate prior patch.

Probably end up looking like:

drivers/mmc/host/sdhci- renamed from drivers/mmc/host/sdhci-of-dwcmshc.c +0 -0

of-dwcmshc.c
index 20aa9b6327d2..c9b020b7a3f6 100644

drivers/mmc/host/sdhci-of-dwcmshc.c +12 -3
@@ -652,17 +652,33 @@ static int dwcmshc_resume(struct device *dev)
 	if (!IS_ERR(priv->bus_clk)) {
 		ret = clk_prepare_enable(priv->bus_clk);
 		if (ret)
-			return ret;
+			goto disable_clk;
 	}
 
 	if (rk_priv) {
 		ret = clk_bulk_prepare_enable(RK35xx_MAX_CLKS,
 					      rk_priv->rockchip_clks);
 		if (ret)
-			return ret;
+			goto disable_bus_clk;
 	}
 
-	return sdhci_resume_host(host);
+	ret = sdhci_resume_host(host);
+	if (ret)
+		goto disable_rockchip_clks;
+
+	pm_runtime_put(dev);
+
+	return 0;
+
+disable_rockchip_clks:
+	if (rk_priv)

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 684

Quoted 10 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +7 -0
+		clk_bulk_disable_unprepare(RK35xx_MAX_CLKS, rk_priv-
 >rockchip_clks);
+disable_bus_clk:
+	if (!IS_ERR(priv->bus_clk))
+		clk_disable_unprepare(priv->bus_clk);
+disable_clk:
+	clk_disable_unprepare(pltfm_host->clk);
+	return ret;
 }
 #endif

Do you mean a separate 'post' patch? I left it out in v9 and could post another one for this error path. Or do you prefer the same patch series?

Quoted 63 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 649

Quoted 9 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +0 -1
 {
 	struct sdhci_host *host = dev_get_drvdata(dev);
@@ -646,7 +668,55 @@ static int dwcmshc_resume(struct device *dev)
 }
 #endif
 
-static SIMPLE_DEV_PM_OPS(dwcmshc_pmops, dwcmshc_suspend,

dwcmshc_resume);

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 678

Quoted 8 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +8 -0
+#ifdef CONFIG_PM
+
+static void dwcmshc_enable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	if ((ctrl & SDHCI_CLOCK_INT_EN) && !(ctrl &

SDHCI_CLOCK_CARD_EN)) {

Quoted 44 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +41 -0
+		ctrl |= SDHCI_CLOCK_CARD_EN;
+		sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+	}
+}
+
+static void dwcmshc_disable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	if (ctrl & SDHCI_CLOCK_CARD_EN) {
+		ctrl &= ~SDHCI_CLOCK_CARD_EN;
+		sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+	}
+}
+
+static int dwcmshc_runtime_suspend(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+
+	dwcmshc_disable_card_clk(host);
+
+	return 0;
+}
+
+static int dwcmshc_runtime_resume(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+
+	dwcmshc_enable_card_clk(host);
+
+	return 0;
+}
+
+#endif
+
+static const struct dev_pm_ops dwcmshc_pmops = {
+	SET_SYSTEM_SLEEP_PM_OPS(dwcmshc_suspend, dwcmshc_resume)
+	SET_RUNTIME_PM_OPS(dwcmshc_runtime_suspend,
+			   dwcmshc_runtime_resume, NULL)
+};
 
 static struct platform_driver sdhci_dwcmshc_driver = {
 	.driver	= {
maintainer
#30 lore raw

Re: [PATCH v8] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 199 lines · Liming Sun
Quoted 97 lines

-----Original Message-----
From: Adrian Hunter <[email protected]>
Sent: Thursday, August 17, 2023 3:36 AM
To: Liming Sun <[email protected]>; Ulf Hansson <[email protected]>; David Thompson <[email protected]>; Shawn Lin <shawn.lin@rock- chips.com>
Cc: [email protected]; [email protected]
Subject: Re: [PATCH v8] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 27 lines · Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v7->v8:
- Address Ulf's comment (option-1);
- Updates for Adrian;s comment to remove the force_suspend/resume in dwcmshc_resume()/dwcmshc_suspend(); Add comments for dwcmshc_resume()/dwcmshc_suspend();
v6->v7:
- Address Ulf's comment;
v5->v6:
- Address Adrian's more comments and add coordination between runtime PM and system PM;
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

Quoted 2 lines
---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 76

+++++++++++++++++++++++++++--

drivers/mmc/host/sdhci-

Quoted 3 lines
 1 file changed, 73 insertions(+), 3 deletions(-)
drivers/mmc/host/sdhci- renamed from drivers/mmc/host/sdhci-of-dwcmshc.c +0 -0

of-dwcmshc.c

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_probe(struct platform_device

Quoted 12 lines

index e68cd87998c8..2196218c9d79 100644

drivers/mmc/host/sdhci-of-dwcmshc.c +1 -0
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -548,9 +549,13 @@ static int dwcmshc_probe(struct platform_device

*pdev)

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_probe(struct platform_device

Quoted 15 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +5 -1
 	host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
+	pm_runtime_get_noresume(dev);
+	pm_runtime_set_active(dev);
+	pm_runtime_enable(dev);
+
 	err = sdhci_setup_host(host);
 	if (err)
-		goto err_clk;
+		goto err_rpm;
 
 	if (rk_priv)
 		dwcmshc_rk35xx_postinit(host, priv);
@@ -559,10 +564,15 @@ static int dwcmshc_probe(struct platform_device

*pdev)

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_remove(struct platform_device

Quoted 16 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +5 -0
 	if (err)
 		goto err_setup_host;
 
+	pm_runtime_put(dev);
+
 	return 0;
 
 err_setup_host:
 	sdhci_cleanup_host(host);
+err_rpm:
+	pm_runtime_disable(dev);
+	pm_runtime_put_noidle(dev);
 err_clk:
 	clk_disable_unprepare(pltfm_host->clk);
 	clk_disable_unprepare(priv->bus_clk);
@@ -594,6 +604,10 @@ static int dwcmshc_remove(struct platform_device

*pdev)

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_remove(struct platform_device · line 608

Quoted 5 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +2 -0
 }
 
 #ifdef CONFIG_PM_SLEEP
+/*
+ * Note, runtime suspend changes only SDHCI_CLOCK_CARD_EN which has
Quoted 6 lines

no effect on

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_remove(struct platform_device · line 610

Quoted 2 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +2 -0
+ * system suspend.
+ */

This comment isn't needed since pm_runtime_get_sync() will always runtime resume the device if needed.

Updated in v9.

Quoted 8 lines
Quoted 8 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +0 -0
 static int dwcmshc_suspend(struct device *dev)
 {
 	struct sdhci_host *host = dev_get_drvdata(dev);
@@ -602,9 +616,11 @@ static int dwcmshc_suspend(struct device *dev)
 	struct rk35xx_priv *rk_priv = priv->priv;
 	int ret;
 
Quoted 4 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_suspend(struct device *dev) · line 619

Quoted 1 line
drivers/mmc/host/sdhci-of-dwcmshc.c +1 -0
+	pm_runtime_get_sync(dev);

This needs a corresponding pm_runtime_put() at the end of dwcmshc_resume().

Updated in v9.

Quoted 18 lines
Quoted 18 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +4 -1
+
 	ret = sdhci_suspend_host(host);
 	if (ret)
-		return ret;
+		goto err_suspend;
 
 	clk_disable_unprepare(pltfm_host->clk);
 	if (!IS_ERR(priv->bus_clk))
@@ -614,9 +630,15 @@ static int dwcmshc_suspend(struct device *dev)
 		clk_bulk_disable_unprepare(RK35xx_MAX_CLKS,
 					   rk_priv->rockchip_clks);
 
+err_suspend:
+	pm_runtime_put_noidle(dev);
 	return ret;
 }
 
Quoted 7 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_suspend(struct device *dev) · line 639

Quoted 2 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +2 -0
+/*
+ * Note, system resume leaves SDHCI_CLOCK_INT_EN off which is consistent

with

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_suspend(struct device *dev) · line 641

Quoted 2 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +2 -0
+ * either runtime suspended or runtime resumed.
+ */

As above, this comment isn't needed.

Updated in v9.

Quoted 6 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_suspend(struct device *dev) · line 642

Quoted 2 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +0 -0
 static int dwcmshc_resume(struct device *dev)

As mentioned above, dwcmshc_resume() needs a pm_runtime_put() to balance the pm_runtime_get_sync().

Updated in v9.

Quoted 41 lines

Could fix up the error path too, but that should be a separate prior patch.

Probably end up looking like:

drivers/mmc/host/sdhci- renamed from drivers/mmc/host/sdhci-of-dwcmshc.c +0 -0

of-dwcmshc.c
index 20aa9b6327d2..c9b020b7a3f6 100644

drivers/mmc/host/sdhci-of-dwcmshc.c +13 -3
@@ -652,17 +652,33 @@ static int dwcmshc_resume(struct device *dev)
 	if (!IS_ERR(priv->bus_clk)) {
 		ret = clk_prepare_enable(priv->bus_clk);
 		if (ret)
-			return ret;
+			goto disable_clk;
 	}
 
 	if (rk_priv) {
 		ret = clk_bulk_prepare_enable(RK35xx_MAX_CLKS,
 					      rk_priv->rockchip_clks);
 		if (ret)
-			return ret;
+			goto disable_bus_clk;
 	}
 
-	return sdhci_resume_host(host);
+	ret = sdhci_resume_host(host);
+	if (ret)
+		goto disable_rockchip_clks;
+
+	pm_runtime_put(dev);
+
+	return 0;
+
+disable_rockchip_clks:
+	if (rk_priv)
+		clk_bulk_disable_unprepare(RK35xx_MAX_CLKS, rk_priv-
 > rockchip_clks);
Quoted 12 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 683

Quoted 10 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +6 -0
+disable_bus_clk:
+	if (!IS_ERR(priv->bus_clk))
+		clk_disable_unprepare(priv->bus_clk);
+disable_clk:
+	clk_disable_unprepare(pltfm_host->clk);
+	return ret;
 }
 #endif

Do you mean a separate 'post' patch? I left it out in v9 and could post another one for this error path. Or do you prefer the same patch series?

Same patch series, 2 patches. First patch fixes the error paths in dwcmshc_resume(). Second patch adds runtime pm.

Quoted 65 lines
Quoted 64 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 649

Quoted 10 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +0 -1
 {
 	struct sdhci_host *host = dev_get_drvdata(dev);
@@ -646,7 +668,55 @@ static int dwcmshc_resume(struct device *dev)
 }
 #endif
 
-static SIMPLE_DEV_PM_OPS(dwcmshc_pmops, dwcmshc_suspend,

dwcmshc_resume);

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 678

Quoted 8 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +8 -0
+#ifdef CONFIG_PM
+
+static void dwcmshc_enable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	if ((ctrl & SDHCI_CLOCK_INT_EN) && !(ctrl &

SDHCI_CLOCK_CARD_EN)) {

Quoted 44 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +41 -0
+		ctrl |= SDHCI_CLOCK_CARD_EN;
+		sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+	}
+}
+
+static void dwcmshc_disable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	if (ctrl & SDHCI_CLOCK_CARD_EN) {
+		ctrl &= ~SDHCI_CLOCK_CARD_EN;
+		sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+	}
+}
+
+static int dwcmshc_runtime_suspend(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+
+	dwcmshc_disable_card_clk(host);
+
+	return 0;
+}
+
+static int dwcmshc_runtime_resume(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+
+	dwcmshc_enable_card_clk(host);
+
+	return 0;
+}
+
+#endif
+
+static const struct dev_pm_ops dwcmshc_pmops = {
+	SET_SYSTEM_SLEEP_PM_OPS(dwcmshc_suspend, dwcmshc_resume)
+	SET_RUNTIME_PM_OPS(dwcmshc_runtime_suspend,
+			   dwcmshc_runtime_resume, NULL)
+};
 
 static struct platform_driver sdhci_dwcmshc_driver = {
 	.driver	= {
author
#31 lore raw

PATCH v9 1/1 mmc: sdhci-of-dwcmshc: Add runtime PM operations

In reply to Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v8->v9:
- Address Adrian's comment to do the pm_runtime_put() in dwcmshc_resume() instead; Error path changes not included yet.
v7->v8:
- Address Ulf's comment (option-1);
- Updates for Adrian's comment to remove the force_suspend/resume in dwcmshc_resume()/dwcmshc_suspend(); Add comments for dwcmshc_resume()/dwcmshc_suspend();
v6->v7:
- Address Ulf's comment;
v5->v6:
- Address Adrian's more comments and add coordination between runtime PM and system PM;
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 76 +++++++++++++++++++++++++++--
 1 file changed, 72 insertions(+), 4 deletions(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +72 -4
index e68cd87998c8..3b40f55ce2a4 100644
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -548,9 +549,13 @@ static int dwcmshc_probe(struct platform_device *pdev)
 
 	host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
+	pm_runtime_get_noresume(dev);
+	pm_runtime_set_active(dev);
+	pm_runtime_enable(dev);
+
 	err = sdhci_setup_host(host);
 	if (err)
-		goto err_clk;
+		goto err_rpm;
 
 	if (rk_priv)
 		dwcmshc_rk35xx_postinit(host, priv);
@@ -559,10 +564,15 @@ static int dwcmshc_probe(struct platform_device *pdev)
 	if (err)
 		goto err_setup_host;
 
+	pm_runtime_put(dev);
+
 	return 0;
 
 err_setup_host:
 	sdhci_cleanup_host(host);
+err_rpm:
+	pm_runtime_disable(dev);
+	pm_runtime_put_noidle(dev);
 err_clk:
 	clk_disable_unprepare(pltfm_host->clk);
 	clk_disable_unprepare(priv->bus_clk);
@@ -602,9 +612,13 @@ static int dwcmshc_suspend(struct device *dev)
 	struct rk35xx_priv *rk_priv = priv->priv;
 	int ret;
 
+	pm_runtime_get_sync(dev);
+
 	ret = sdhci_suspend_host(host);
-	if (ret)
+	if (ret) {
+		pm_runtime_put(dev);
 		return ret;
+	}
 
 	clk_disable_unprepare(pltfm_host->clk);
 	if (!IS_ERR(priv->bus_clk))
@@ -642,11 +656,65 @@ static int dwcmshc_resume(struct device *dev)
 			return ret;
 	}
 
-	return sdhci_resume_host(host);
+	ret = sdhci_resume_host(host);
+	if (ret)
+		return ret;
+
+	pm_runtime_put(dev);
+
+	return 0;
 }
 #endif
 
-static SIMPLE_DEV_PM_OPS(dwcmshc_pmops, dwcmshc_suspend, dwcmshc_resume);
+#ifdef CONFIG_PM
+
+static void dwcmshc_enable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	if ((ctrl & SDHCI_CLOCK_INT_EN) && !(ctrl & SDHCI_CLOCK_CARD_EN)) {
+		ctrl |= SDHCI_CLOCK_CARD_EN;
+		sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+	}
+}
+
+static void dwcmshc_disable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	if (ctrl & SDHCI_CLOCK_CARD_EN) {
+		ctrl &= ~SDHCI_CLOCK_CARD_EN;
+		sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+	}
+}
+
+static int dwcmshc_runtime_suspend(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+
+	dwcmshc_disable_card_clk(host);
+
+	return 0;
+}
+
+static int dwcmshc_runtime_resume(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+
+	dwcmshc_enable_card_clk(host);
+
+	return 0;
+}
+
+#endif
+
+static const struct dev_pm_ops dwcmshc_pmops = {
+	SET_SYSTEM_SLEEP_PM_OPS(dwcmshc_suspend, dwcmshc_resume)
+	SET_RUNTIME_PM_OPS(dwcmshc_runtime_suspend,
+			   dwcmshc_runtime_resume, NULL)
+};
 
 static struct platform_driver sdhci_dwcmshc_driver = {
 	.driver	= {
Signature · 1 line
2.30.1
#32 lore raw

Re: [PATCH v9] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 94 lines · Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v8->v9:
- Address Adrian's comment to do the pm_runtime_put() in dwcmshc_resume() instead; Error path changes not included yet.
v7->v8:
- Address Ulf's comment (option-1);
- Updates for Adrian's comment to remove the force_suspend/resume in dwcmshc_resume()/dwcmshc_suspend(); Add comments for dwcmshc_resume()/dwcmshc_suspend();
v6->v7:
- Address Ulf's comment;
v5->v6:
- Address Adrian's more comments and add coordination between runtime PM and system PM;
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 76 +++++++++++++++++++++++++++--
 1 file changed, 72 insertions(+), 4 deletions(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +16 -2
index e68cd87998c8..3b40f55ce2a4 100644
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -548,9 +549,13 @@ static int dwcmshc_probe(struct platform_device *pdev)
 
        host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
+       pm_runtime_get_noresume(dev);
+       pm_runtime_set_active(dev);
+       pm_runtime_enable(dev);
+
        err = sdhci_setup_host(host);
        if (err)
-               goto err_clk;
+               goto err_rpm;
 
        if (rk_priv)
                dwcmshc_rk35xx_postinit(host, priv);
@@ -559,10 +564,15 @@ static int dwcmshc_probe(struct platform_device *pdev)
        if (err)
                goto err_setup_host;
 
+       pm_runtime_put(dev);
+
        return 0;
 
 err_setup_host:
        sdhci_cleanup_host(host);
+err_rpm:
+       pm_runtime_disable(dev);
+       pm_runtime_put_noidle(dev);
 err_clk:
        clk_disable_unprepare(pltfm_host->clk);
        clk_disable_unprepare(priv->bus_clk);
@@ -602,9 +612,13 @@ static int dwcmshc_suspend(struct device *dev)
        struct rk35xx_priv *rk_priv = priv->priv;
        int ret;
 
+       pm_runtime_get_sync(dev);
+
        ret = sdhci_suspend_host(host);
-       if (ret)
+       if (ret) {
+               pm_runtime_put(dev);
                return ret;
+       }
 
        clk_disable_unprepare(pltfm_host->clk);
        if (!IS_ERR(priv->bus_clk))

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 663

Quoted 9 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +5 -1
@@ -642,11 +656,65 @@ static int dwcmshc_resume(struct device *dev)
                        return ret;
        }
 
-       return sdhci_resume_host(host);
+       ret = sdhci_resume_host(host);
+       if (ret)
+               return ret;
+
+       pm_runtime_put(dev);

To simplify the error path, I would suggest that you move the call to pm_runtime_put() to dwcmshc_suspend(). In fact what you need is just a call to pm_runtime_put_noidle(), somewhere after the call to pm_runtime_get_sync().

This is because runtime suspend is prevented by the PM core as it bumps the usage count with a pm_runtime_get_noresume() in the device_prepare() phase.

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 667

Quoted 4 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +2 -0
+
+       return 0;
 }
 #endif

[...]

Kind regards
Uffe

maintainer
#33 lore raw

Re: [PATCH v9] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 110 lines · Ulf Hansson
Quoted 94 lines · Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v8->v9:
- Address Adrian's comment to do the pm_runtime_put() in dwcmshc_resume() instead; Error path changes not included yet.
v7->v8:
- Address Ulf's comment (option-1);
- Updates for Adrian's comment to remove the force_suspend/resume in dwcmshc_resume()/dwcmshc_suspend(); Add comments for dwcmshc_resume()/dwcmshc_suspend();
v6->v7:
- Address Ulf's comment;
v5->v6:
- Address Adrian's more comments and add coordination between runtime PM and system PM;
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 76 +++++++++++++++++++++++++++--
 1 file changed, 72 insertions(+), 4 deletions(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +16 -2
index e68cd87998c8..3b40f55ce2a4 100644
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -548,9 +549,13 @@ static int dwcmshc_probe(struct platform_device *pdev)
 
        host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
+       pm_runtime_get_noresume(dev);
+       pm_runtime_set_active(dev);
+       pm_runtime_enable(dev);
+
        err = sdhci_setup_host(host);
        if (err)
-               goto err_clk;
+               goto err_rpm;
 
        if (rk_priv)
                dwcmshc_rk35xx_postinit(host, priv);
@@ -559,10 +564,15 @@ static int dwcmshc_probe(struct platform_device *pdev)
        if (err)
                goto err_setup_host;
 
+       pm_runtime_put(dev);
+
        return 0;
 
 err_setup_host:
        sdhci_cleanup_host(host);
+err_rpm:
+       pm_runtime_disable(dev);
+       pm_runtime_put_noidle(dev);
 err_clk:
        clk_disable_unprepare(pltfm_host->clk);
        clk_disable_unprepare(priv->bus_clk);
@@ -602,9 +612,13 @@ static int dwcmshc_suspend(struct device *dev)
        struct rk35xx_priv *rk_priv = priv->priv;
        int ret;
 
+       pm_runtime_get_sync(dev);
+
        ret = sdhci_suspend_host(host);
-       if (ret)
+       if (ret) {
+               pm_runtime_put(dev);
                return ret;
+       }
 
        clk_disable_unprepare(pltfm_host->clk);
        if (!IS_ERR(priv->bus_clk))

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 663

Quoted 9 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +5 -1
@@ -642,11 +656,65 @@ static int dwcmshc_resume(struct device *dev)
                        return ret;
        }
 
-       return sdhci_resume_host(host);
+       ret = sdhci_resume_host(host);
+       if (ret)
+               return ret;
+
+       pm_runtime_put(dev);

To simplify the error path, I would suggest that you move the call to pm_runtime_put() to dwcmshc_suspend(). In fact what you need is just a call to pm_runtime_put_noidle(), somewhere after the call to pm_runtime_get_sync().

Quoted 3 lines

This is because runtime suspend is prevented by the PM core as it bumps the usage count with a pm_runtime_get_noresume() in the device_prepare() phase.

I thought you didn't want to assume that, because in that case it can just be pm_runtime_resume() instead of pm_runtime_get_sync(), and then no 'put' is needed at all.

Quoted 10 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 667

Quoted 5 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +2 -0
+
+       return 0;
 }
 #endif

[...]

Kind regards
Uffe

#34 lore raw

Re: [PATCH v9] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 112 lines · Adrian Hunter
Quoted 110 lines · Ulf Hansson
Quoted 94 lines · Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v8->v9:
- Address Adrian's comment to do the pm_runtime_put() in dwcmshc_resume() instead; Error path changes not included yet.
v7->v8:
- Address Ulf's comment (option-1);
- Updates for Adrian's comment to remove the force_suspend/resume in dwcmshc_resume()/dwcmshc_suspend(); Add comments for dwcmshc_resume()/dwcmshc_suspend();
v6->v7:
- Address Ulf's comment;
v5->v6:
- Address Adrian's more comments and add coordination between runtime PM and system PM;
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 76 +++++++++++++++++++++++++++--
 1 file changed, 72 insertions(+), 4 deletions(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +16 -2
index e68cd87998c8..3b40f55ce2a4 100644
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -548,9 +549,13 @@ static int dwcmshc_probe(struct platform_device *pdev)
 
        host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
+       pm_runtime_get_noresume(dev);
+       pm_runtime_set_active(dev);
+       pm_runtime_enable(dev);
+
        err = sdhci_setup_host(host);
        if (err)
-               goto err_clk;
+               goto err_rpm;
 
        if (rk_priv)
                dwcmshc_rk35xx_postinit(host, priv);
@@ -559,10 +564,15 @@ static int dwcmshc_probe(struct platform_device *pdev)
        if (err)
                goto err_setup_host;
 
+       pm_runtime_put(dev);
+
        return 0;
 
 err_setup_host:
        sdhci_cleanup_host(host);
+err_rpm:
+       pm_runtime_disable(dev);
+       pm_runtime_put_noidle(dev);
 err_clk:
        clk_disable_unprepare(pltfm_host->clk);
        clk_disable_unprepare(priv->bus_clk);
@@ -602,9 +612,13 @@ static int dwcmshc_suspend(struct device *dev)
        struct rk35xx_priv *rk_priv = priv->priv;
        int ret;
 
+       pm_runtime_get_sync(dev);
+
        ret = sdhci_suspend_host(host);
-       if (ret)
+       if (ret) {
+               pm_runtime_put(dev);
                return ret;
+       }
 
        clk_disable_unprepare(pltfm_host->clk);
        if (!IS_ERR(priv->bus_clk))

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 663

Quoted 9 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +5 -1
@@ -642,11 +656,65 @@ static int dwcmshc_resume(struct device *dev)
                        return ret;
        }
 
-       return sdhci_resume_host(host);
+       ret = sdhci_resume_host(host);
+       if (ret)
+               return ret;
+
+       pm_runtime_put(dev);

To simplify the error path, I would suggest that you move the call to pm_runtime_put() to dwcmshc_suspend(). In fact what you need is just a call to pm_runtime_put_noidle(), somewhere after the call to pm_runtime_get_sync().

Quoted 7 lines
Quoted 3 lines

This is because runtime suspend is prevented by the PM core as it bumps the usage count with a pm_runtime_get_noresume() in the device_prepare() phase.

I thought you didn't want to assume that, because in that case it can just be pm_runtime_resume() instead of pm_runtime_get_sync(), and then no 'put' is needed at all.

I don't really care, but just wanted to keep it as simple as possible.

So yes, I am fine with a pm_runtime_resume() too. Maybe even simpler in this case, as we are not using pm_runtime_force_suspend|resume() anymore.

Kind regards
Uffe

author
#35 lore raw

RE: [PATCH v9] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 137 lines

-----Original Message-----
From: Ulf Hansson <[email protected]>
Sent: Friday, August 18, 2023 6:19 AM
To: Adrian Hunter <[email protected]>
Cc: Liming Sun <[email protected]>; David Thompson <[email protected]>; Shawn Lin <[email protected]>; linux- [email protected]; [email protected]
Subject: Re: [PATCH v9] mmc: sdhci-of-dwcmshc: Add runtime PM operations

Quoted 28 lines · Adrian Hunter
Quoted 26 lines · Ulf Hansson
Quoted 25 lines · Liming Sun

This commit implements the runtime PM operations to disable eMMC card clock when idle.

---
v8->v9:
- Address Adrian's comment to do the pm_runtime_put() in dwcmshc_resume() instead; Error path changes not included yet.
v7->v8:
- Address Ulf's comment (option-1);
- Updates for Adrian's comment to remove the force_suspend/resume in dwcmshc_resume()/dwcmshc_suspend(); Add comments for dwcmshc_resume()/dwcmshc_suspend();
v6->v7:
- Address Ulf's comment;
v5->v6:
- Address Adrian's more comments and add coordination between runtime PM and system PM;
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 76

+++++++++++++++++++++++++++--

Quoted 3 lines
Quoted 3 lines

Review

Quoted 3 lines
 1 file changed, 72 insertions(+), 4 deletions(-)
(quoted diff) +0 -0

b/drivers/mmc/host/sdhci-of-dwcmshc.c

Quoted 11 lines
Quoted 11 lines
Quoted 11 lines

index e68cd87998c8..3b40f55ce2a4 100644

drivers/mmc/host/sdhci-of-dwcmshc.c +1 -0
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
Quoted 1 line
Quoted 1 line

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_probe(struct

Quoted 1 line
drivers/mmc/host/sdhci-of-dwcmshc.c +0 -0
@@ -548,9 +549,13 @@ static int dwcmshc_probe(struct

platform_device *pdev)

Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +5 -1
        host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
+       pm_runtime_get_noresume(dev);
+       pm_runtime_set_active(dev);
+       pm_runtime_enable(dev);
+
        err = sdhci_setup_host(host);
        if (err)
-               goto err_clk;
+               goto err_rpm;
 
Quoted 3 lines
Quoted 3 lines

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_probe(struct

Quoted 3 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +0 -0
        if (rk_priv)
                dwcmshc_rk35xx_postinit(host, priv);
@@ -559,10 +564,15 @@ static int dwcmshc_probe(struct

platform_device *pdev)

Quoted 46 lines
Quoted 46 lines
Quoted 31 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +10 -1
        if (err)
                goto err_setup_host;
 
+       pm_runtime_put(dev);
+
        return 0;
 
 err_setup_host:
        sdhci_cleanup_host(host);
+err_rpm:
+       pm_runtime_disable(dev);
+       pm_runtime_put_noidle(dev);
 err_clk:
        clk_disable_unprepare(pltfm_host->clk);
        clk_disable_unprepare(priv->bus_clk);
@@ -602,9 +612,13 @@ static int dwcmshc_suspend(struct device *dev)
        struct rk35xx_priv *rk_priv = priv->priv;
        int ret;
 
+       pm_runtime_get_sync(dev);
+
        ret = sdhci_suspend_host(host);
-       if (ret)
+       if (ret) {
+               pm_runtime_put(dev);
                return ret;
+       }
 
        clk_disable_unprepare(pltfm_host->clk);
        if (!IS_ERR(priv->bus_clk))

drivers/mmc/host/sdhci-of-dwcmshc.c static int dwcmshc_resume(struct device *dev) · line 663

Quoted 9 lines
drivers/mmc/host/sdhci-of-dwcmshc.c +5 -1
@@ -642,11 +656,65 @@ static int dwcmshc_resume(struct device *dev)
                        return ret;
        }
 
-       return sdhci_resume_host(host);
+       ret = sdhci_resume_host(host);
+       if (ret)
+               return ret;
+
+       pm_runtime_put(dev);

To simplify the error path, I would suggest that you move the call to pm_runtime_put() to dwcmshc_suspend(). In fact what you need is just a call to pm_runtime_put_noidle(), somewhere after the call to pm_runtime_get_sync().

Quoted 7 lines
Quoted 3 lines

This is because runtime suspend is prevented by the PM core as it bumps the usage count with a pm_runtime_get_noresume() in the device_prepare() phase.

I thought you didn't want to assume that, because in that case it can just be pm_runtime_resume() instead of pm_runtime_get_sync(), and then no 'put' is needed at all.

Quoted 5 lines

I don't really care, but just wanted to keep it as simple as possible.

So yes, I am fine with a pm_runtime_resume() too. Maybe even simpler in this case, as we are not using pm_runtime_force_suspend|resume() anymore.

Thanks. Will post v10 with ' pm_runtime_resume(dev);' in dwcmshc_suspend() to keep it simple.

Quoted 3 lines

Kind regards
Uffe

author
#36 lore raw

PATCH v10 1/2 mmc : sdhci-of-dwcmshc : add error handling in dwcmshc_resume

In reply to Liming Sun

This commit adds handling in dwcmshc_resume() for different error cases.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 21 ++++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +18 -3
index 31c1892f4ecd..bc332a035032 100644
@@ -630,17 +630,32 @@ static int dwcmshc_resume(struct device *dev)
 	if (!IS_ERR(priv->bus_clk)) {
 		ret = clk_prepare_enable(priv->bus_clk);
 		if (ret)
-			return ret;
+			goto disable_clk;
 	}
 
 	if (rk_priv) {
 		ret = clk_bulk_prepare_enable(RK35xx_MAX_CLKS,
 					      rk_priv->rockchip_clks);
 		if (ret)
-			return ret;
+			goto disable_bus_clk;
 	}
 
-	return sdhci_resume_host(host);
+	ret = sdhci_resume_host(host);
+	if (ret)
+		goto disable_rockchip_clks;
+
+	return 0;
+
+disable_rockchip_clks:
+	if (rk_priv)
+		clk_bulk_disable_unprepare(RK35xx_MAX_CLKS,
+					   rk_priv->rockchip_clks);
+disable_bus_clk:
+	if (!IS_ERR(priv->bus_clk))
+		clk_disable_unprepare(priv->bus_clk);
+disable_clk:
+	clk_disable_unprepare(pltfm_host->clk);
+	return ret;
 }
 #endif
 
Signature · 1 line
2.30.1
maintainer Acked-by on v10 1/2
#37 lore raw

Re: [PATCH v10 1/2] mmc : sdhci-of-dwcmshc : add error handling in dwcmshc_resume

Quoted 4 lines · Liming Sun

This commit adds handling in dwcmshc_resume() for different error cases.

We don't put a space before ":" in the subject line, and usually capitalize after that i.e.

mmc: sdhci-of-dwcmshc: Add error handling in dwcmshc_resume()

Otherwise:

Quoted 44 lines
---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 21 ++++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +18 -3
index 31c1892f4ecd..bc332a035032 100644
@@ -630,17 +630,32 @@ static int dwcmshc_resume(struct device *dev)
 	if (!IS_ERR(priv->bus_clk)) {
 		ret = clk_prepare_enable(priv->bus_clk);
 		if (ret)
-			return ret;
+			goto disable_clk;
 	}
 
 	if (rk_priv) {
 		ret = clk_bulk_prepare_enable(RK35xx_MAX_CLKS,
 					      rk_priv->rockchip_clks);
 		if (ret)
-			return ret;
+			goto disable_bus_clk;
 	}
 
-	return sdhci_resume_host(host);
+	ret = sdhci_resume_host(host);
+	if (ret)
+		goto disable_rockchip_clks;
+
+	return 0;
+
+disable_rockchip_clks:
+	if (rk_priv)
+		clk_bulk_disable_unprepare(RK35xx_MAX_CLKS,
+					   rk_priv->rockchip_clks);
+disable_bus_clk:
+	if (!IS_ERR(priv->bus_clk))
+		clk_disable_unprepare(priv->bus_clk);
+disable_clk:
+	clk_disable_unprepare(pltfm_host->clk);
+	return ret;
 }
 #endif
 
#38 lore raw

Re: [PATCH v10 1/2] mmc : sdhci-of-dwcmshc : add error handling in dwcmshc_resume

In reply to Liming Sun
Quoted 5 lines · Liming Sun

This commit adds handling in dwcmshc_resume() for different error cases.

Applied for next (I amended the patch according to Adrian's suggestions), thanks!

Kind regards
Uffe

Quoted 47 lines
---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 21 ++++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +18 -4
index 31c1892f4ecd..bc332a035032 100644
@@ -630,17 +630,32 @@ static int dwcmshc_resume(struct device *dev)
        if (!IS_ERR(priv->bus_clk)) {
                ret = clk_prepare_enable(priv->bus_clk);
                if (ret)
-                       return ret;
+                       goto disable_clk;
        }
 
        if (rk_priv) {
                ret = clk_bulk_prepare_enable(RK35xx_MAX_CLKS,
                                              rk_priv->rockchip_clks);
                if (ret)
-                       return ret;
+                       goto disable_bus_clk;
        }
 
-       return sdhci_resume_host(host);
+       ret = sdhci_resume_host(host);
+       if (ret)
+               goto disable_rockchip_clks;
+
+       return 0;
+
+disable_rockchip_clks:
+       if (rk_priv)
+               clk_bulk_disable_unprepare(RK35xx_MAX_CLKS,
+                                          rk_priv->rockchip_clks);
+disable_bus_clk:
+       if (!IS_ERR(priv->bus_clk))
+               clk_disable_unprepare(priv->bus_clk);
+disable_clk:
+       clk_disable_unprepare(pltfm_host->clk);
+       return ret;
 }
 #endif
 
--

2.30.1

author
#39 lore raw

PATCH v10 2/2 This commit implements the runtime PM operations to disable eMMC card clock when idle.

In reply to Liming Sun

---
v9->v10:
- Simplify the changes with pm_runtime_resume() in dwcmshc_suspend().
v8->v9:
- Address Adrian's comment to do the pm_runtime_put() in dwcmshc_resume() instead; Error path changes not included yet.
v7->v8:
- Address Ulf's comment (option-1);
- Updates for Adrian's comment to remove the force_suspend/resume in dwcmshc_resume()/dwcmshc_suspend(); Add comments for dwcmshc_resume()/dwcmshc_suspend();
v6->v7:
- Address Ulf's comment;
v5->v6:
- Address Adrian's more comments and add coordination between runtime PM and system PM;
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 64 ++++++++++++++++++++++++++++-
 1 file changed, 62 insertions(+), 2 deletions(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +62 -2
index bc332a035032..3a3bae6948a8 100644
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -548,9 +549,13 @@ static int dwcmshc_probe(struct platform_device *pdev)
 
 	host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
+	pm_runtime_get_noresume(dev);
+	pm_runtime_set_active(dev);
+	pm_runtime_enable(dev);
+
 	err = sdhci_setup_host(host);
 	if (err)
-		goto err_clk;
+		goto err_rpm;
 
 	if (rk_priv)
 		dwcmshc_rk35xx_postinit(host, priv);
@@ -559,10 +564,15 @@ static int dwcmshc_probe(struct platform_device *pdev)
 	if (err)
 		goto err_setup_host;
 
+	pm_runtime_put(dev);
+
 	return 0;
 
 err_setup_host:
 	sdhci_cleanup_host(host);
+err_rpm:
+	pm_runtime_disable(dev);
+	pm_runtime_put_noidle(dev);
 err_clk:
 	clk_disable_unprepare(pltfm_host->clk);
 	clk_disable_unprepare(priv->bus_clk);
@@ -600,6 +610,8 @@ static int dwcmshc_suspend(struct device *dev)
 	struct rk35xx_priv *rk_priv = priv->priv;
 	int ret;
 
+	pm_runtime_resume(dev);
+
 	ret = sdhci_suspend_host(host);
 	if (ret)
 		return ret;
@@ -659,7 +671,55 @@ static int dwcmshc_resume(struct device *dev)
 }
 #endif
 
-static SIMPLE_DEV_PM_OPS(dwcmshc_pmops, dwcmshc_suspend, dwcmshc_resume);
+#ifdef CONFIG_PM
+
+static void dwcmshc_enable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	if ((ctrl & SDHCI_CLOCK_INT_EN) && !(ctrl & SDHCI_CLOCK_CARD_EN)) {
+		ctrl |= SDHCI_CLOCK_CARD_EN;
+		sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+	}
+}
+
+static void dwcmshc_disable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	if (ctrl & SDHCI_CLOCK_CARD_EN) {
+		ctrl &= ~SDHCI_CLOCK_CARD_EN;
+		sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+	}
+}
+
+static int dwcmshc_runtime_suspend(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+
+	dwcmshc_disable_card_clk(host);
+
+	return 0;
+}
+
+static int dwcmshc_runtime_resume(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+
+	dwcmshc_enable_card_clk(host);
+
+	return 0;
+}
+
+#endif
+
+static const struct dev_pm_ops dwcmshc_pmops = {
+	SET_SYSTEM_SLEEP_PM_OPS(dwcmshc_suspend, dwcmshc_resume)
+	SET_RUNTIME_PM_OPS(dwcmshc_runtime_suspend,
+			   dwcmshc_runtime_resume, NULL)
+};
 
 static struct platform_driver sdhci_dwcmshc_driver = {
 	.driver	= {
Signature · 1 line
2.30.1
maintainer Acked-by on v10 2/2
#40 lore raw

Re: [PATCH v10 2/2] This commit implements the runtime PM operations to disable eMMC card clock when idle.

Quoted 2 lines · Liming Sun

Seem the subject line got lost (it was OK in v9), and the description is in the subject line.

Apart from that:

Quoted 141 lines

---
v9->v10:
- Simplify the changes with pm_runtime_resume() in dwcmshc_suspend().
v8->v9:
- Address Adrian's comment to do the pm_runtime_put() in dwcmshc_resume() instead; Error path changes not included yet.
v7->v8:
- Address Ulf's comment (option-1);
- Updates for Adrian's comment to remove the force_suspend/resume in dwcmshc_resume()/dwcmshc_suspend(); Add comments for dwcmshc_resume()/dwcmshc_suspend();
v6->v7:
- Address Ulf's comment;
v5->v6:
- Address Adrian's more comments and add coordination between runtime PM and system PM;
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 64 ++++++++++++++++++++++++++++-
 1 file changed, 62 insertions(+), 2 deletions(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +62 -2
index bc332a035032..3a3bae6948a8 100644
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -548,9 +549,13 @@ static int dwcmshc_probe(struct platform_device *pdev)
 
 	host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
+	pm_runtime_get_noresume(dev);
+	pm_runtime_set_active(dev);
+	pm_runtime_enable(dev);
+
 	err = sdhci_setup_host(host);
 	if (err)
-		goto err_clk;
+		goto err_rpm;
 
 	if (rk_priv)
 		dwcmshc_rk35xx_postinit(host, priv);
@@ -559,10 +564,15 @@ static int dwcmshc_probe(struct platform_device *pdev)
 	if (err)
 		goto err_setup_host;
 
+	pm_runtime_put(dev);
+
 	return 0;
 
 err_setup_host:
 	sdhci_cleanup_host(host);
+err_rpm:
+	pm_runtime_disable(dev);
+	pm_runtime_put_noidle(dev);
 err_clk:
 	clk_disable_unprepare(pltfm_host->clk);
 	clk_disable_unprepare(priv->bus_clk);
@@ -600,6 +610,8 @@ static int dwcmshc_suspend(struct device *dev)
 	struct rk35xx_priv *rk_priv = priv->priv;
 	int ret;
 
+	pm_runtime_resume(dev);
+
 	ret = sdhci_suspend_host(host);
 	if (ret)
 		return ret;
@@ -659,7 +671,55 @@ static int dwcmshc_resume(struct device *dev)
 }
 #endif
 
-static SIMPLE_DEV_PM_OPS(dwcmshc_pmops, dwcmshc_suspend, dwcmshc_resume);
+#ifdef CONFIG_PM
+
+static void dwcmshc_enable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	if ((ctrl & SDHCI_CLOCK_INT_EN) && !(ctrl & SDHCI_CLOCK_CARD_EN)) {
+		ctrl |= SDHCI_CLOCK_CARD_EN;
+		sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+	}
+}
+
+static void dwcmshc_disable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	if (ctrl & SDHCI_CLOCK_CARD_EN) {
+		ctrl &= ~SDHCI_CLOCK_CARD_EN;
+		sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+	}
+}
+
+static int dwcmshc_runtime_suspend(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+
+	dwcmshc_disable_card_clk(host);
+
+	return 0;
+}
+
+static int dwcmshc_runtime_resume(struct device *dev)
+{
+	struct sdhci_host *host = dev_get_drvdata(dev);
+
+	dwcmshc_enable_card_clk(host);
+
+	return 0;
+}
+
+#endif
+
+static const struct dev_pm_ops dwcmshc_pmops = {
+	SET_SYSTEM_SLEEP_PM_OPS(dwcmshc_suspend, dwcmshc_resume)
+	SET_RUNTIME_PM_OPS(dwcmshc_runtime_suspend,
+			   dwcmshc_runtime_resume, NULL)
+};
 
 static struct platform_driver sdhci_dwcmshc_driver = {
 	.driver	= {
#41 lore raw

Re: [PATCH v10 2/2] This commit implements the runtime PM operations to disable eMMC card clock when idle.

In reply to Liming Sun
Quoted 3 lines · Liming Sun

Applied for next (I amended the patch according to Adrian's suggestions), thanks!

Kind regards
Uffe

Quoted 144 lines

---
v9->v10:
- Simplify the changes with pm_runtime_resume() in dwcmshc_suspend().
v8->v9:
- Address Adrian's comment to do the pm_runtime_put() in dwcmshc_resume() instead; Error path changes not included yet.
v7->v8:
- Address Ulf's comment (option-1);
- Updates for Adrian's comment to remove the force_suspend/resume in dwcmshc_resume()/dwcmshc_suspend(); Add comments for dwcmshc_resume()/dwcmshc_suspend();
v6->v7:
- Address Ulf's comment;
v5->v6:
- Address Adrian's more comments and add coordination between runtime PM and system PM;
v4->v5:
- Address Adrian's comment to move the pm_enable to the end to avoid race;
v3->v4:
- Fix compiling reported by 'kernel test robot';
v2->v3:
- Revise the commit message;
v1->v2:
Updates for comments from Ulf:
- Make the runtime PM logic generic for sdhci-of-dwcmshc;
v1: Initial version.

---
 drivers/mmc/host/sdhci-of-dwcmshc.c | 64 ++++++++++++++++++++++++++++-
 1 file changed, 62 insertions(+), 2 deletions(-)
drivers/mmc/host/sdhci-of-dwcmshc.c +62 -3
index bc332a035032..3a3bae6948a8 100644
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/reset.h>
 #include <linux/sizes.h>
 
@@ -548,9 +549,13 @@ static int dwcmshc_probe(struct platform_device *pdev)
 
        host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 
+       pm_runtime_get_noresume(dev);
+       pm_runtime_set_active(dev);
+       pm_runtime_enable(dev);
+
        err = sdhci_setup_host(host);
        if (err)
-               goto err_clk;
+               goto err_rpm;
 
        if (rk_priv)
                dwcmshc_rk35xx_postinit(host, priv);
@@ -559,10 +564,15 @@ static int dwcmshc_probe(struct platform_device *pdev)
        if (err)
                goto err_setup_host;
 
+       pm_runtime_put(dev);
+
        return 0;
 
 err_setup_host:
        sdhci_cleanup_host(host);
+err_rpm:
+       pm_runtime_disable(dev);
+       pm_runtime_put_noidle(dev);
 err_clk:
        clk_disable_unprepare(pltfm_host->clk);
        clk_disable_unprepare(priv->bus_clk);
@@ -600,6 +610,8 @@ static int dwcmshc_suspend(struct device *dev)
        struct rk35xx_priv *rk_priv = priv->priv;
        int ret;
 
+       pm_runtime_resume(dev);
+
        ret = sdhci_suspend_host(host);
        if (ret)
                return ret;
@@ -659,7 +671,55 @@ static int dwcmshc_resume(struct device *dev)
 }
 #endif
 
-static SIMPLE_DEV_PM_OPS(dwcmshc_pmops, dwcmshc_suspend, dwcmshc_resume);
+#ifdef CONFIG_PM
+
+static void dwcmshc_enable_card_clk(struct sdhci_host *host)
+{
+       u16 ctrl;
+
+       ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+       if ((ctrl & SDHCI_CLOCK_INT_EN) && !(ctrl & SDHCI_CLOCK_CARD_EN)) {
+               ctrl |= SDHCI_CLOCK_CARD_EN;
+               sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+       }
+}
+
+static void dwcmshc_disable_card_clk(struct sdhci_host *host)
+{
+       u16 ctrl;
+
+       ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+       if (ctrl & SDHCI_CLOCK_CARD_EN) {
+               ctrl &= ~SDHCI_CLOCK_CARD_EN;
+               sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+       }
+}
+
+static int dwcmshc_runtime_suspend(struct device *dev)
+{
+       struct sdhci_host *host = dev_get_drvdata(dev);
+
+       dwcmshc_disable_card_clk(host);
+
+       return 0;
+}
+
+static int dwcmshc_runtime_resume(struct device *dev)
+{
+       struct sdhci_host *host = dev_get_drvdata(dev);
+
+       dwcmshc_enable_card_clk(host);
+
+       return 0;
+}
+
+#endif
+
+static const struct dev_pm_ops dwcmshc_pmops = {
+       SET_SYSTEM_SLEEP_PM_OPS(dwcmshc_suspend, dwcmshc_resume)
+       SET_RUNTIME_PM_OPS(dwcmshc_runtime_suspend,
+                          dwcmshc_runtime_resume, NULL)
+};
 
 static struct platform_driver sdhci_dwcmshc_driver = {
        .driver = {
--

2.30.1