Re: [PATCH v7 1/2] usb: xhci: plat: Enable runtime PM

2016-12-14 Thread Baolin Wang 
Hi Robert,

On 14 December 2016 at 14:43, Robert Foss  wrote:
> Hey Baolin,
>
> On 2016-12-12 12:21 AM, Baolin Wang wrote:
>>
>> Hi Robert,
>>
>> On 2 December 2016 at 05:46, Robert Foss 
>> wrote:
>>>
>>> Enable runtime PM for the xhci-plat device so that the parent device
>>> may implement runtime PM.
>>>
>>> Signed-off-by: Robert Foss 
>>>
>>> Tested-by: Robert Foss 
>>> ---
>>>  drivers/usb/host/xhci-plat.c | 29 +++--
>>>  1 file changed, 27 insertions(+), 2 deletions(-)
>>>
>>> diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
>>> index ed56bf9ed885..ba4efe74f537 100644
>>> --- a/drivers/usb/host/xhci-plat.c
>>> +++ b/drivers/usb/host/xhci-plat.c
>>> @@ -246,6 +246,9 @@ static int xhci_plat_probe(struct platform_device
>>> *pdev)
>>> if (ret)
>>> goto dealloc_usb2_hcd;
>>>
>>> +   pm_runtime_set_active(>dev);
>>> +   pm_runtime_enable(>dev);
>>
>>
>> You did not implement the runtime callbacks of xHCI device, then how
>> can the parent device control the resume/suspend of xHCI device by
>> runtime PM mechanism? Could you see my previous patch which implement
>> the runtime callbacks for xHCI device?
>> https://lkml.org/lkml/2016/11/28/25
>>
>
> Pardon my ignorance, but which exact functions need to be implemented?
> Also, does the lkml link you provided contain an example implementation of
> those functions?

Please check below link:
https://lkml.org/lkml/2016/12/13/32
https://lkml.org/lkml/2016/12/13/34

>
>
>>> +
>>> return 0;
>>>
>>>
>>> @@ -274,6 +277,8 @@ static int xhci_plat_remove(struct platform_device
>>> *dev)
>>> struct xhci_hcd *xhci = hcd_to_xhci(hcd);
>>> struct clk *clk = xhci->clk;
>>>
>>> +   pm_runtime_disable(>dev);
>>> +
>>> usb_remove_hcd(xhci->shared_hcd);
>>> usb_phy_shutdown(hcd->usb_phy);
>>>
>>> @@ -292,6 +297,13 @@ static int xhci_plat_suspend(struct device *dev)
>>>  {
>>> struct usb_hcd  *hcd = dev_get_drvdata(dev);
>>> struct xhci_hcd *xhci = hcd_to_xhci(hcd);
>>> +   int ret;
>>> +
>>> +   ret = pm_runtime_get_sync(dev);
>>> +   if (ret < 0) {
>>> +   pm_runtime_put(dev);
>>> +   return ret;
>>> +   }
>>>
>>> /*
>>>  * xhci_suspend() needs `do_wakeup` to know whether host is
>>> allowed
>>> @@ -301,15 +313,28 @@ static int xhci_plat_suspend(struct device *dev)
>>>  * reconsider this when xhci_plat_suspend enlarges its scope,
>>> e.g.,
>>>  * also applies to runtime suspend.
>>>  */
>>> -   return xhci_suspend(xhci, device_may_wakeup(dev));
>>> +   ret = xhci_suspend(xhci, device_may_wakeup(dev));
>>> +   pm_runtime_put(dev);
>>> +
>>> +   return ret;
>>>  }
>>>
>>>  static int xhci_plat_resume(struct device *dev)
>>>  {
>>> struct usb_hcd  *hcd = dev_get_drvdata(dev);
>>> struct xhci_hcd *xhci = hcd_to_xhci(hcd);
>>> +   int ret;
>>>
>>> -   return xhci_resume(xhci, 0);
>>> +   ret = pm_runtime_get_sync(dev);
>>> +   if (ret < 0) {
>>> +   pm_runtime_put(dev);
>>> +   return ret;
>>> +   }
>>> +
>>> +   ret = xhci_resume(xhci, 0);
>>> +   pm_runtime_put(dev);
>>> +
>>> +   return ret;
>>>  }
>>>
>>>  static const struct dev_pm_ops xhci_plat_pm_ops = {
>>> --
>>> 2.11.0
>>>
>>
>>
>>
>



-- 
Baolin.wang
Best Regards

Re: [PATCH v7 1/2] usb: xhci: plat: Enable runtime PM

2016-12-14 Thread Baolin Wang 
Hi Robert,

On 14 December 2016 at 14:43, Robert Foss  wrote:
> Hey Baolin,
>
> On 2016-12-12 12:21 AM, Baolin Wang wrote:
>>
>> Hi Robert,
>>
>> On 2 December 2016 at 05:46, Robert Foss 
>> wrote:
>>>
>>> Enable runtime PM for the xhci-plat device so that the parent device
>>> may implement runtime PM.
>>>
>>> Signed-off-by: Robert Foss 
>>>
>>> Tested-by: Robert Foss 
>>> ---
>>>  drivers/usb/host/xhci-plat.c | 29 +++--
>>>  1 file changed, 27 insertions(+), 2 deletions(-)
>>>
>>> diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
>>> index ed56bf9ed885..ba4efe74f537 100644
>>> --- a/drivers/usb/host/xhci-plat.c
>>> +++ b/drivers/usb/host/xhci-plat.c
>>> @@ -246,6 +246,9 @@ static int xhci_plat_probe(struct platform_device
>>> *pdev)
>>> if (ret)
>>> goto dealloc_usb2_hcd;
>>>
>>> +   pm_runtime_set_active(>dev);
>>> +   pm_runtime_enable(>dev);
>>
>>
>> You did not implement the runtime callbacks of xHCI device, then how
>> can the parent device control the resume/suspend of xHCI device by
>> runtime PM mechanism? Could you see my previous patch which implement
>> the runtime callbacks for xHCI device?
>> https://lkml.org/lkml/2016/11/28/25
>>
>
> Pardon my ignorance, but which exact functions need to be implemented?
> Also, does the lkml link you provided contain an example implementation of
> those functions?

Please check below link:
https://lkml.org/lkml/2016/12/13/32
https://lkml.org/lkml/2016/12/13/34

>
>
>>> +
>>> return 0;
>>>
>>>
>>> @@ -274,6 +277,8 @@ static int xhci_plat_remove(struct platform_device
>>> *dev)
>>> struct xhci_hcd *xhci = hcd_to_xhci(hcd);
>>> struct clk *clk = xhci->clk;
>>>
>>> +   pm_runtime_disable(>dev);
>>> +
>>> usb_remove_hcd(xhci->shared_hcd);
>>> usb_phy_shutdown(hcd->usb_phy);
>>>
>>> @@ -292,6 +297,13 @@ static int xhci_plat_suspend(struct device *dev)
>>>  {
>>> struct usb_hcd  *hcd = dev_get_drvdata(dev);
>>> struct xhci_hcd *xhci = hcd_to_xhci(hcd);
>>> +   int ret;
>>> +
>>> +   ret = pm_runtime_get_sync(dev);
>>> +   if (ret < 0) {
>>> +   pm_runtime_put(dev);
>>> +   return ret;
>>> +   }
>>>
>>> /*
>>>  * xhci_suspend() needs `do_wakeup` to know whether host is
>>> allowed
>>> @@ -301,15 +313,28 @@ static int xhci_plat_suspend(struct device *dev)
>>>  * reconsider this when xhci_plat_suspend enlarges its scope,
>>> e.g.,
>>>  * also applies to runtime suspend.
>>>  */
>>> -   return xhci_suspend(xhci, device_may_wakeup(dev));
>>> +   ret = xhci_suspend(xhci, device_may_wakeup(dev));
>>> +   pm_runtime_put(dev);
>>> +
>>> +   return ret;
>>>  }
>>>
>>>  static int xhci_plat_resume(struct device *dev)
>>>  {
>>> struct usb_hcd  *hcd = dev_get_drvdata(dev);
>>> struct xhci_hcd *xhci = hcd_to_xhci(hcd);
>>> +   int ret;
>>>
>>> -   return xhci_resume(xhci, 0);
>>> +   ret = pm_runtime_get_sync(dev);
>>> +   if (ret < 0) {
>>> +   pm_runtime_put(dev);
>>> +   return ret;
>>> +   }
>>> +
>>> +   ret = xhci_resume(xhci, 0);
>>> +   pm_runtime_put(dev);
>>> +
>>> +   return ret;
>>>  }
>>>
>>>  static const struct dev_pm_ops xhci_plat_pm_ops = {
>>> --
>>> 2.11.0
>>>
>>
>>
>>
>



-- 
Baolin.wang
Best Regards

Re: [PATCH v7 1/2] usb: xhci: plat: Enable runtime PM

2016-12-13 Thread Robert Foss 

Hey Baolin,

On 2016-12-12 12:21 AM, Baolin Wang wrote:

Hi Robert,

On 2 December 2016 at 05:46, Robert Foss  wrote:

Enable runtime PM for the xhci-plat device so that the parent device
may implement runtime PM.

Signed-off-by: Robert Foss 

Tested-by: Robert Foss 
---
 drivers/usb/host/xhci-plat.c | 29 +++--
 1 file changed, 27 insertions(+), 2 deletions(-)

diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
index ed56bf9ed885..ba4efe74f537 100644
--- a/drivers/usb/host/xhci-plat.c
+++ b/drivers/usb/host/xhci-plat.c
@@ -246,6 +246,9 @@ static int xhci_plat_probe(struct platform_device *pdev)
if (ret)
goto dealloc_usb2_hcd;

+   pm_runtime_set_active(>dev);
+   pm_runtime_enable(>dev);


You did not implement the runtime callbacks of xHCI device, then how
can the parent device control the resume/suspend of xHCI device by
runtime PM mechanism? Could you see my previous patch which implement
the runtime callbacks for xHCI device?
https://lkml.org/lkml/2016/11/28/25



Pardon my ignorance, but which exact functions need to be implemented?
Also, does the lkml link you provided contain an example implementation 
of those functions?



+
return 0;


@@ -274,6 +277,8 @@ static int xhci_plat_remove(struct platform_device *dev)
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
struct clk *clk = xhci->clk;

+   pm_runtime_disable(>dev);
+
usb_remove_hcd(xhci->shared_hcd);
usb_phy_shutdown(hcd->usb_phy);

@@ -292,6 +297,13 @@ static int xhci_plat_suspend(struct device *dev)
 {
struct usb_hcd  *hcd = dev_get_drvdata(dev);
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+   int ret;
+
+   ret = pm_runtime_get_sync(dev);
+   if (ret < 0) {
+   pm_runtime_put(dev);
+   return ret;
+   }

/*
 * xhci_suspend() needs `do_wakeup` to know whether host is allowed
@@ -301,15 +313,28 @@ static int xhci_plat_suspend(struct device *dev)
 * reconsider this when xhci_plat_suspend enlarges its scope, e.g.,
 * also applies to runtime suspend.
 */
-   return xhci_suspend(xhci, device_may_wakeup(dev));
+   ret = xhci_suspend(xhci, device_may_wakeup(dev));
+   pm_runtime_put(dev);
+
+   return ret;
 }

 static int xhci_plat_resume(struct device *dev)
 {
struct usb_hcd  *hcd = dev_get_drvdata(dev);
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+   int ret;

-   return xhci_resume(xhci, 0);
+   ret = pm_runtime_get_sync(dev);
+   if (ret < 0) {
+   pm_runtime_put(dev);
+   return ret;
+   }
+
+   ret = xhci_resume(xhci, 0);
+   pm_runtime_put(dev);
+
+   return ret;
 }

 static const struct dev_pm_ops xhci_plat_pm_ops = {
--
2.11.0

Re: [PATCH v7 1/2] usb: xhci: plat: Enable runtime PM

2016-12-13 Thread Robert Foss 

Hey Baolin,

On 2016-12-12 12:21 AM, Baolin Wang wrote:

Hi Robert,

On 2 December 2016 at 05:46, Robert Foss  wrote:

Enable runtime PM for the xhci-plat device so that the parent device
may implement runtime PM.

Signed-off-by: Robert Foss 

Tested-by: Robert Foss 
---
 drivers/usb/host/xhci-plat.c | 29 +++--
 1 file changed, 27 insertions(+), 2 deletions(-)

diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
index ed56bf9ed885..ba4efe74f537 100644
--- a/drivers/usb/host/xhci-plat.c
+++ b/drivers/usb/host/xhci-plat.c
@@ -246,6 +246,9 @@ static int xhci_plat_probe(struct platform_device *pdev)
if (ret)
goto dealloc_usb2_hcd;

+   pm_runtime_set_active(>dev);
+   pm_runtime_enable(>dev);


You did not implement the runtime callbacks of xHCI device, then how
can the parent device control the resume/suspend of xHCI device by
runtime PM mechanism? Could you see my previous patch which implement
the runtime callbacks for xHCI device?
https://lkml.org/lkml/2016/11/28/25



Pardon my ignorance, but which exact functions need to be implemented?
Also, does the lkml link you provided contain an example implementation 
of those functions?



+
return 0;


@@ -274,6 +277,8 @@ static int xhci_plat_remove(struct platform_device *dev)
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
struct clk *clk = xhci->clk;

+   pm_runtime_disable(>dev);
+
usb_remove_hcd(xhci->shared_hcd);
usb_phy_shutdown(hcd->usb_phy);

@@ -292,6 +297,13 @@ static int xhci_plat_suspend(struct device *dev)
 {
struct usb_hcd  *hcd = dev_get_drvdata(dev);
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+   int ret;
+
+   ret = pm_runtime_get_sync(dev);
+   if (ret < 0) {
+   pm_runtime_put(dev);
+   return ret;
+   }

/*
 * xhci_suspend() needs `do_wakeup` to know whether host is allowed
@@ -301,15 +313,28 @@ static int xhci_plat_suspend(struct device *dev)
 * reconsider this when xhci_plat_suspend enlarges its scope, e.g.,
 * also applies to runtime suspend.
 */
-   return xhci_suspend(xhci, device_may_wakeup(dev));
+   ret = xhci_suspend(xhci, device_may_wakeup(dev));
+   pm_runtime_put(dev);
+
+   return ret;
 }

 static int xhci_plat_resume(struct device *dev)
 {
struct usb_hcd  *hcd = dev_get_drvdata(dev);
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+   int ret;

-   return xhci_resume(xhci, 0);
+   ret = pm_runtime_get_sync(dev);
+   if (ret < 0) {
+   pm_runtime_put(dev);
+   return ret;
+   }
+
+   ret = xhci_resume(xhci, 0);
+   pm_runtime_put(dev);
+
+   return ret;
 }

 static const struct dev_pm_ops xhci_plat_pm_ops = {
--
2.11.0

Re: [PATCH v7 1/2] usb: xhci: plat: Enable runtime PM

2016-12-11 Thread Baolin Wang 
Hi Robert,

On 2 December 2016 at 05:46, Robert Foss  wrote:
> Enable runtime PM for the xhci-plat device so that the parent device
> may implement runtime PM.
>
> Signed-off-by: Robert Foss 
>
> Tested-by: Robert Foss 
> ---
>  drivers/usb/host/xhci-plat.c | 29 +++--
>  1 file changed, 27 insertions(+), 2 deletions(-)
>
> diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
> index ed56bf9ed885..ba4efe74f537 100644
> --- a/drivers/usb/host/xhci-plat.c
> +++ b/drivers/usb/host/xhci-plat.c
> @@ -246,6 +246,9 @@ static int xhci_plat_probe(struct platform_device *pdev)
> if (ret)
> goto dealloc_usb2_hcd;
>
> +   pm_runtime_set_active(>dev);
> +   pm_runtime_enable(>dev);

You did not implement the runtime callbacks of xHCI device, then how
can the parent device control the resume/suspend of xHCI device by
runtime PM mechanism? Could you see my previous patch which implement
the runtime callbacks for xHCI device?
https://lkml.org/lkml/2016/11/28/25

> +
> return 0;
>
>
> @@ -274,6 +277,8 @@ static int xhci_plat_remove(struct platform_device *dev)
> struct xhci_hcd *xhci = hcd_to_xhci(hcd);
> struct clk *clk = xhci->clk;
>
> +   pm_runtime_disable(>dev);
> +
> usb_remove_hcd(xhci->shared_hcd);
> usb_phy_shutdown(hcd->usb_phy);
>
> @@ -292,6 +297,13 @@ static int xhci_plat_suspend(struct device *dev)
>  {
> struct usb_hcd  *hcd = dev_get_drvdata(dev);
> struct xhci_hcd *xhci = hcd_to_xhci(hcd);
> +   int ret;
> +
> +   ret = pm_runtime_get_sync(dev);
> +   if (ret < 0) {
> +   pm_runtime_put(dev);
> +   return ret;
> +   }
>
> /*
>  * xhci_suspend() needs `do_wakeup` to know whether host is allowed
> @@ -301,15 +313,28 @@ static int xhci_plat_suspend(struct device *dev)
>  * reconsider this when xhci_plat_suspend enlarges its scope, e.g.,
>  * also applies to runtime suspend.
>  */
> -   return xhci_suspend(xhci, device_may_wakeup(dev));
> +   ret = xhci_suspend(xhci, device_may_wakeup(dev));
> +   pm_runtime_put(dev);
> +
> +   return ret;
>  }
>
>  static int xhci_plat_resume(struct device *dev)
>  {
> struct usb_hcd  *hcd = dev_get_drvdata(dev);
> struct xhci_hcd *xhci = hcd_to_xhci(hcd);
> +   int ret;
>
> -   return xhci_resume(xhci, 0);
> +   ret = pm_runtime_get_sync(dev);
> +   if (ret < 0) {
> +   pm_runtime_put(dev);
> +   return ret;
> +   }
> +
> +   ret = xhci_resume(xhci, 0);
> +   pm_runtime_put(dev);
> +
> +   return ret;
>  }
>
>  static const struct dev_pm_ops xhci_plat_pm_ops = {
> --
> 2.11.0
>



-- 
Baolin.wang
Best Regards

Re: [PATCH v7 1/2] usb: xhci: plat: Enable runtime PM

2016-12-11 Thread Baolin Wang 
Hi Robert,

On 2 December 2016 at 05:46, Robert Foss  wrote:
> Enable runtime PM for the xhci-plat device so that the parent device
> may implement runtime PM.
>
> Signed-off-by: Robert Foss 
>
> Tested-by: Robert Foss 
> ---
>  drivers/usb/host/xhci-plat.c | 29 +++--
>  1 file changed, 27 insertions(+), 2 deletions(-)
>
> diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
> index ed56bf9ed885..ba4efe74f537 100644
> --- a/drivers/usb/host/xhci-plat.c
> +++ b/drivers/usb/host/xhci-plat.c
> @@ -246,6 +246,9 @@ static int xhci_plat_probe(struct platform_device *pdev)
> if (ret)
> goto dealloc_usb2_hcd;
>
> +   pm_runtime_set_active(>dev);
> +   pm_runtime_enable(>dev);

You did not implement the runtime callbacks of xHCI device, then how
can the parent device control the resume/suspend of xHCI device by
runtime PM mechanism? Could you see my previous patch which implement
the runtime callbacks for xHCI device?
https://lkml.org/lkml/2016/11/28/25

> +
> return 0;
>
>
> @@ -274,6 +277,8 @@ static int xhci_plat_remove(struct platform_device *dev)
> struct xhci_hcd *xhci = hcd_to_xhci(hcd);
> struct clk *clk = xhci->clk;
>
> +   pm_runtime_disable(>dev);
> +
> usb_remove_hcd(xhci->shared_hcd);
> usb_phy_shutdown(hcd->usb_phy);
>
> @@ -292,6 +297,13 @@ static int xhci_plat_suspend(struct device *dev)
>  {
> struct usb_hcd  *hcd = dev_get_drvdata(dev);
> struct xhci_hcd *xhci = hcd_to_xhci(hcd);
> +   int ret;
> +
> +   ret = pm_runtime_get_sync(dev);
> +   if (ret < 0) {
> +   pm_runtime_put(dev);
> +   return ret;
> +   }
>
> /*
>  * xhci_suspend() needs `do_wakeup` to know whether host is allowed
> @@ -301,15 +313,28 @@ static int xhci_plat_suspend(struct device *dev)
>  * reconsider this when xhci_plat_suspend enlarges its scope, e.g.,
>  * also applies to runtime suspend.
>  */
> -   return xhci_suspend(xhci, device_may_wakeup(dev));
> +   ret = xhci_suspend(xhci, device_may_wakeup(dev));
> +   pm_runtime_put(dev);
> +
> +   return ret;
>  }
>
>  static int xhci_plat_resume(struct device *dev)
>  {
> struct usb_hcd  *hcd = dev_get_drvdata(dev);
> struct xhci_hcd *xhci = hcd_to_xhci(hcd);
> +   int ret;
>
> -   return xhci_resume(xhci, 0);
> +   ret = pm_runtime_get_sync(dev);
> +   if (ret < 0) {
> +   pm_runtime_put(dev);
> +   return ret;
> +   }
> +
> +   ret = xhci_resume(xhci, 0);
> +   pm_runtime_put(dev);
> +
> +   return ret;
>  }
>
>  static const struct dev_pm_ops xhci_plat_pm_ops = {
> --
> 2.11.0
>



-- 
Baolin.wang
Best Regards

[PATCH v7 1/2] usb: xhci: plat: Enable runtime PM

2016-12-01 Thread Robert Foss 
Enable runtime PM for the xhci-plat device so that the parent device
may implement runtime PM.

Signed-off-by: Robert Foss 

Tested-by: Robert Foss 
---
 drivers/usb/host/xhci-plat.c | 29 +++--
 1 file changed, 27 insertions(+), 2 deletions(-)

diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
index ed56bf9ed885..ba4efe74f537 100644
--- a/drivers/usb/host/xhci-plat.c
+++ b/drivers/usb/host/xhci-plat.c
@@ -246,6 +246,9 @@ static int xhci_plat_probe(struct platform_device *pdev)
if (ret)
goto dealloc_usb2_hcd;
 
+   pm_runtime_set_active(>dev);
+   pm_runtime_enable(>dev);
+
return 0;
 
 
@@ -274,6 +277,8 @@ static int xhci_plat_remove(struct platform_device *dev)
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
struct clk *clk = xhci->clk;
 
+   pm_runtime_disable(>dev);
+
usb_remove_hcd(xhci->shared_hcd);
usb_phy_shutdown(hcd->usb_phy);
 
@@ -292,6 +297,13 @@ static int xhci_plat_suspend(struct device *dev)
 {
struct usb_hcd  *hcd = dev_get_drvdata(dev);
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+   int ret;
+
+   ret = pm_runtime_get_sync(dev);
+   if (ret < 0) {
+   pm_runtime_put(dev);
+   return ret;
+   }
 
/*
 * xhci_suspend() needs `do_wakeup` to know whether host is allowed
@@ -301,15 +313,28 @@ static int xhci_plat_suspend(struct device *dev)
 * reconsider this when xhci_plat_suspend enlarges its scope, e.g.,
 * also applies to runtime suspend.
 */
-   return xhci_suspend(xhci, device_may_wakeup(dev));
+   ret = xhci_suspend(xhci, device_may_wakeup(dev));
+   pm_runtime_put(dev);
+
+   return ret;
 }
 
 static int xhci_plat_resume(struct device *dev)
 {
struct usb_hcd  *hcd = dev_get_drvdata(dev);
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+   int ret;
 
-   return xhci_resume(xhci, 0);
+   ret = pm_runtime_get_sync(dev);
+   if (ret < 0) {
+   pm_runtime_put(dev);
+   return ret;
+   }
+
+   ret = xhci_resume(xhci, 0);
+   pm_runtime_put(dev);
+
+   return ret;
 }
 
 static const struct dev_pm_ops xhci_plat_pm_ops = {
-- 
2.11.0

[PATCH v7 1/2] usb: xhci: plat: Enable runtime PM

2016-12-01 Thread Robert Foss 
Enable runtime PM for the xhci-plat device so that the parent device
may implement runtime PM.

Signed-off-by: Robert Foss 

Tested-by: Robert Foss 
---
 drivers/usb/host/xhci-plat.c | 29 +++--
 1 file changed, 27 insertions(+), 2 deletions(-)

diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
index ed56bf9ed885..ba4efe74f537 100644
--- a/drivers/usb/host/xhci-plat.c
+++ b/drivers/usb/host/xhci-plat.c
@@ -246,6 +246,9 @@ static int xhci_plat_probe(struct platform_device *pdev)
if (ret)
goto dealloc_usb2_hcd;
 
+   pm_runtime_set_active(>dev);
+   pm_runtime_enable(>dev);
+
return 0;
 
 
@@ -274,6 +277,8 @@ static int xhci_plat_remove(struct platform_device *dev)
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
struct clk *clk = xhci->clk;
 
+   pm_runtime_disable(>dev);
+
usb_remove_hcd(xhci->shared_hcd);
usb_phy_shutdown(hcd->usb_phy);
 
@@ -292,6 +297,13 @@ static int xhci_plat_suspend(struct device *dev)
 {
struct usb_hcd  *hcd = dev_get_drvdata(dev);
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+   int ret;
+
+   ret = pm_runtime_get_sync(dev);
+   if (ret < 0) {
+   pm_runtime_put(dev);
+   return ret;
+   }
 
/*
 * xhci_suspend() needs `do_wakeup` to know whether host is allowed
@@ -301,15 +313,28 @@ static int xhci_plat_suspend(struct device *dev)
 * reconsider this when xhci_plat_suspend enlarges its scope, e.g.,
 * also applies to runtime suspend.
 */
-   return xhci_suspend(xhci, device_may_wakeup(dev));
+   ret = xhci_suspend(xhci, device_may_wakeup(dev));
+   pm_runtime_put(dev);
+
+   return ret;
 }
 
 static int xhci_plat_resume(struct device *dev)
 {
struct usb_hcd  *hcd = dev_get_drvdata(dev);
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+   int ret;
 
-   return xhci_resume(xhci, 0);
+   ret = pm_runtime_get_sync(dev);
+   if (ret < 0) {
+   pm_runtime_put(dev);
+   return ret;
+   }
+
+   ret = xhci_resume(xhci, 0);
+   pm_runtime_put(dev);
+
+   return ret;
 }
 
 static const struct dev_pm_ops xhci_plat_pm_ops = {
-- 
2.11.0

[PATCH v7 1/2] usb: xhci: plat: Enable runtime PM

2016-12-01 Thread Robert Foss 
Enable runtime PM for the xhci-plat device so that the parent device
may implement runtime PM.

Signed-off-by: Robert Foss 

Tested-by: Robert Foss 
---
 drivers/usb/host/xhci-plat.c | 29 +++--
 1 file changed, 27 insertions(+), 2 deletions(-)

diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
index ed56bf9ed885..ba4efe74f537 100644
--- a/drivers/usb/host/xhci-plat.c
+++ b/drivers/usb/host/xhci-plat.c
@@ -246,6 +246,9 @@ static int xhci_plat_probe(struct platform_device *pdev)
if (ret)
goto dealloc_usb2_hcd;
 
+   pm_runtime_set_active(>dev);
+   pm_runtime_enable(>dev);
+
return 0;
 
 
@@ -274,6 +277,8 @@ static int xhci_plat_remove(struct platform_device *dev)
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
struct clk *clk = xhci->clk;
 
+   pm_runtime_disable(>dev);
+
usb_remove_hcd(xhci->shared_hcd);
usb_phy_shutdown(hcd->usb_phy);
 
@@ -292,6 +297,13 @@ static int xhci_plat_suspend(struct device *dev)
 {
struct usb_hcd  *hcd = dev_get_drvdata(dev);
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+   int ret;
+
+   ret = pm_runtime_get_sync(dev);
+   if (ret < 0) {
+   pm_runtime_put(dev);
+   return ret;
+   }
 
/*
 * xhci_suspend() needs `do_wakeup` to know whether host is allowed
@@ -301,15 +313,28 @@ static int xhci_plat_suspend(struct device *dev)
 * reconsider this when xhci_plat_suspend enlarges its scope, e.g.,
 * also applies to runtime suspend.
 */
-   return xhci_suspend(xhci, device_may_wakeup(dev));
+   ret = xhci_suspend(xhci, device_may_wakeup(dev));
+   pm_runtime_put(dev);
+
+   return ret;
 }
 
 static int xhci_plat_resume(struct device *dev)
 {
struct usb_hcd  *hcd = dev_get_drvdata(dev);
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+   int ret;
 
-   return xhci_resume(xhci, 0);
+   ret = pm_runtime_get_sync(dev);
+   if (ret < 0) {
+   pm_runtime_put(dev);
+   return ret;
+   }
+
+   ret = xhci_resume(xhci, 0);
+   pm_runtime_put(dev);
+
+   return ret;
 }
 
 static const struct dev_pm_ops xhci_plat_pm_ops = {
-- 
2.11.0

[PATCH v7 1/2] usb: xhci: plat: Enable runtime PM

2016-12-01 Thread Robert Foss 
Enable runtime PM for the xhci-plat device so that the parent device
may implement runtime PM.

Signed-off-by: Robert Foss 

Tested-by: Robert Foss 
---
 drivers/usb/host/xhci-plat.c | 29 +++--
 1 file changed, 27 insertions(+), 2 deletions(-)

diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
index ed56bf9ed885..ba4efe74f537 100644
--- a/drivers/usb/host/xhci-plat.c
+++ b/drivers/usb/host/xhci-plat.c
@@ -246,6 +246,9 @@ static int xhci_plat_probe(struct platform_device *pdev)
if (ret)
goto dealloc_usb2_hcd;
 
+   pm_runtime_set_active(>dev);
+   pm_runtime_enable(>dev);
+
return 0;
 
 
@@ -274,6 +277,8 @@ static int xhci_plat_remove(struct platform_device *dev)
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
struct clk *clk = xhci->clk;
 
+   pm_runtime_disable(>dev);
+
usb_remove_hcd(xhci->shared_hcd);
usb_phy_shutdown(hcd->usb_phy);
 
@@ -292,6 +297,13 @@ static int xhci_plat_suspend(struct device *dev)
 {
struct usb_hcd  *hcd = dev_get_drvdata(dev);
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+   int ret;
+
+   ret = pm_runtime_get_sync(dev);
+   if (ret < 0) {
+   pm_runtime_put(dev);
+   return ret;
+   }
 
/*
 * xhci_suspend() needs `do_wakeup` to know whether host is allowed
@@ -301,15 +313,28 @@ static int xhci_plat_suspend(struct device *dev)
 * reconsider this when xhci_plat_suspend enlarges its scope, e.g.,
 * also applies to runtime suspend.
 */
-   return xhci_suspend(xhci, device_may_wakeup(dev));
+   ret = xhci_suspend(xhci, device_may_wakeup(dev));
+   pm_runtime_put(dev);
+
+   return ret;
 }
 
 static int xhci_plat_resume(struct device *dev)
 {
struct usb_hcd  *hcd = dev_get_drvdata(dev);
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+   int ret;
 
-   return xhci_resume(xhci, 0);
+   ret = pm_runtime_get_sync(dev);
+   if (ret < 0) {
+   pm_runtime_put(dev);
+   return ret;
+   }
+
+   ret = xhci_resume(xhci, 0);
+   pm_runtime_put(dev);
+
+   return ret;
 }
 
 static const struct dev_pm_ops xhci_plat_pm_ops = {
-- 
2.11.0