| Message ID | 20181123141831.8214-6-miquel.raynal@bootlin.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | Bring suspend to RAM support to PCIe Aardvark driver | expand |
[+Rafael, Sudeep] On Fri, Nov 23, 2018 at 03:18:24PM +0100, Miquel Raynal wrote: > Add suspend and resume callbacks. The priority of these are > "_noirq()", to workaround early access to the registers done by the > PCI core through the ->read()/->write() callbacks at resume time. > > Signed-off-by: Miquel Raynal <miquel.raynal@bootlin.com> > --- > drivers/pci/controller/pci-aardvark.c | 52 +++++++++++++++++++++++++++ > 1 file changed, 52 insertions(+) > > diff --git a/drivers/pci/controller/pci-aardvark.c b/drivers/pci/controller/pci-aardvark.c > index 108b3f15c410..7ecf1ac4036b 100644 > --- a/drivers/pci/controller/pci-aardvark.c > +++ b/drivers/pci/controller/pci-aardvark.c > @@ -1108,6 +1108,55 @@ static int advk_pcie_setup_clk(struct advk_pcie *pcie) > return ret; > } > > +static int __maybe_unused advk_pcie_suspend(struct device *dev) > +{ > + struct advk_pcie *pcie = dev_get_drvdata(dev); > + > + advk_pcie_disable_phy(pcie); > + > + clk_disable_unprepare(pcie->clk); I have noticed it is common practice, still, I would like to check whether it is allowed to call functions that may sleep in a NOIRQ suspend/resume callback ? Thanks, Lorenzo > + > + return 0; > +} > + > +static int __maybe_unused advk_pcie_resume(struct device *dev) > +{ > + struct advk_pcie *pcie = dev_get_drvdata(dev); > + int ret; > + > + ret = clk_prepare_enable(pcie->clk); > + if (ret) > + return ret; > + > + /* > + * Empirical delay needed after enabling the clock and before > + * accessing any register. > + */ > + msleep(10); > + > + ret = advk_pcie_enable_phy(pcie); > + if (ret) > + return ret; > + > + advk_pcie_hard_reset(pcie); > + > + advk_pcie_setup_hw(pcie); > + > + advk_sw_pci_bridge_init(pcie); > + > + return 0; > +} > + > +/* > + * The PCI core will try to reconfigure the bus quite early in the resume path. > + * We must use the _noirq() alternatives to ensure the controller is ready when > + * the core uses the ->read()/->write() callbacks. > + */ > +static const struct dev_pm_ops advk_pcie_dev_pm_ops = { > + SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(advk_pcie_suspend, > + advk_pcie_resume) > +}; > + > static int advk_pcie_probe(struct platform_device *pdev) > { > struct device *dev = &pdev->dev; > @@ -1188,6 +1237,8 @@ static int advk_pcie_probe(struct platform_device *pdev) > return ret; > } > > + dev_set_drvdata(dev, pcie); > + > return 0; > } > > @@ -1200,6 +1251,7 @@ static struct platform_driver advk_pcie_driver = { > .driver = { > .name = "advk-pcie", > .of_match_table = advk_pcie_of_match_table, > + .pm = &advk_pcie_dev_pm_ops, > /* Driver unloading/unbinding currently not supported */ > .suppress_bind_attrs = true, > }, > -- > 2.19.1 >
Hi Lorenzo, Lorenzo Pieralisi <lorenzo.pieralisi@arm.com> wrote on Mon, 3 Dec 2018 10:27:08 +0000: > [+Rafael, Sudeep] > > On Fri, Nov 23, 2018 at 03:18:24PM +0100, Miquel Raynal wrote: > > Add suspend and resume callbacks. The priority of these are > > "_noirq()", to workaround early access to the registers done by the > > PCI core through the ->read()/->write() callbacks at resume time. > > > > Signed-off-by: Miquel Raynal <miquel.raynal@bootlin.com> > > --- > > drivers/pci/controller/pci-aardvark.c | 52 +++++++++++++++++++++++++++ > > 1 file changed, 52 insertions(+) > > > > diff --git a/drivers/pci/controller/pci-aardvark.c b/drivers/pci/controller/pci-aardvark.c > > index 108b3f15c410..7ecf1ac4036b 100644 > > --- a/drivers/pci/controller/pci-aardvark.c > > +++ b/drivers/pci/controller/pci-aardvark.c > > @@ -1108,6 +1108,55 @@ static int advk_pcie_setup_clk(struct advk_pcie *pcie) > > return ret; > > } > > > > +static int __maybe_unused advk_pcie_suspend(struct device *dev) > > +{ > > + struct advk_pcie *pcie = dev_get_drvdata(dev); > > + > > + advk_pcie_disable_phy(pcie); > > + > > + clk_disable_unprepare(pcie->clk); > > I have noticed it is common practice, still, I would like to check whether > it is allowed to call functions that may sleep in a NOIRQ suspend/resume > callback ? You are right this is weird. I double checked and for instance, pcie-mediatek.c, pci-tegra.c and pci-imx6.c do the exact same thing. There are probably other cases where drivers call functions that may sleep from a NOIRQ context. I am interested to know if this is valid and if not, what is the alternative? Thanks, Miquèl
[+Stephen, Mike] On Mon, Dec 03, 2018 at 04:38:46PM +0100, Miquel Raynal wrote: > Hi Lorenzo, > > Lorenzo Pieralisi <lorenzo.pieralisi@arm.com> wrote on Mon, 3 Dec 2018 > 10:27:08 +0000: > > > [+Rafael, Sudeep] > > > > On Fri, Nov 23, 2018 at 03:18:24PM +0100, Miquel Raynal wrote: > > > Add suspend and resume callbacks. The priority of these are > > > "_noirq()", to workaround early access to the registers done by the > > > PCI core through the ->read()/->write() callbacks at resume time. > > > > > > Signed-off-by: Miquel Raynal <miquel.raynal@bootlin.com> > > > --- > > > drivers/pci/controller/pci-aardvark.c | 52 +++++++++++++++++++++++++++ > > > 1 file changed, 52 insertions(+) > > > > > > diff --git a/drivers/pci/controller/pci-aardvark.c b/drivers/pci/controller/pci-aardvark.c > > > index 108b3f15c410..7ecf1ac4036b 100644 > > > --- a/drivers/pci/controller/pci-aardvark.c > > > +++ b/drivers/pci/controller/pci-aardvark.c > > > @@ -1108,6 +1108,55 @@ static int advk_pcie_setup_clk(struct advk_pcie *pcie) > > > return ret; > > > } > > > > > > +static int __maybe_unused advk_pcie_suspend(struct device *dev) > > > +{ > > > + struct advk_pcie *pcie = dev_get_drvdata(dev); > > > + > > > + advk_pcie_disable_phy(pcie); > > > + > > > + clk_disable_unprepare(pcie->clk); > > > > I have noticed it is common practice, still, I would like to check whether > > it is allowed to call functions that may sleep in a NOIRQ suspend/resume > > callback ? > > You are right this is weird. I double checked and for instance, > pcie-mediatek.c, pci-tegra.c and pci-imx6.c do the exact same thing. > There are probably other cases where drivers call functions that may > sleep from a NOIRQ context. I am interested to know if this is valid > and if not, what is the alternative? I added Stephen and Mike, who along with Rafael can help us shed some light into this, I do not have the necessary bits of info myself, I just noticed. Lorenzo
Quoting Lorenzo Pieralisi (2018-12-03 09:18:59) > [+Stephen, Mike] > > On Mon, Dec 03, 2018 at 04:38:46PM +0100, Miquel Raynal wrote: > > Hi Lorenzo, > > > > Lorenzo Pieralisi <lorenzo.pieralisi@arm.com> wrote on Mon, 3 Dec 2018 > > 10:27:08 +0000: > > > > > [+Rafael, Sudeep] > > > > > > On Fri, Nov 23, 2018 at 03:18:24PM +0100, Miquel Raynal wrote: > > > > Add suspend and resume callbacks. The priority of these are > > > > "_noirq()", to workaround early access to the registers done by the > > > > PCI core through the ->read()/->write() callbacks at resume time. > > > > > > > > Signed-off-by: Miquel Raynal <miquel.raynal@bootlin.com> > > > > --- > > > > drivers/pci/controller/pci-aardvark.c | 52 +++++++++++++++++++++++++++ > > > > 1 file changed, 52 insertions(+) > > > > > > > > diff --git a/drivers/pci/controller/pci-aardvark.c b/drivers/pci/controller/pci-aardvark.c > > > > index 108b3f15c410..7ecf1ac4036b 100644 > > > > --- a/drivers/pci/controller/pci-aardvark.c > > > > +++ b/drivers/pci/controller/pci-aardvark.c > > > > @@ -1108,6 +1108,55 @@ static int advk_pcie_setup_clk(struct advk_pcie *pcie) > > > > return ret; > > > > } > > > > > > > > +static int __maybe_unused advk_pcie_suspend(struct device *dev) > > > > +{ > > > > + struct advk_pcie *pcie = dev_get_drvdata(dev); > > > > + > > > > + advk_pcie_disable_phy(pcie); > > > > + > > > > + clk_disable_unprepare(pcie->clk); > > > > > > I have noticed it is common practice, still, I would like to check whether > > > it is allowed to call functions that may sleep in a NOIRQ suspend/resume > > > callback ? > > > > You are right this is weird. I double checked and for instance, > > pcie-mediatek.c, pci-tegra.c and pci-imx6.c do the exact same thing. > > There are probably other cases where drivers call functions that may > > sleep from a NOIRQ context. I am interested to know if this is valid > > and if not, what is the alternative? > > I added Stephen and Mike, who along with Rafael can help us shed some > light into this, I do not have the necessary bits of info myself, I just > noticed. > Is the noirq phase of system suspend run with irqs disabled? Or just run with the device irqs disabled? I thought it was the latter, which is fine for this scenario because it's still running in a schedulable context.
On Monday, December 3, 2018 4:38:46 PM CET Miquel Raynal wrote: > Hi Lorenzo, > > Lorenzo Pieralisi <lorenzo.pieralisi@arm.com> wrote on Mon, 3 Dec 2018 > 10:27:08 +0000: > > > [+Rafael, Sudeep] > > > > On Fri, Nov 23, 2018 at 03:18:24PM +0100, Miquel Raynal wrote: > > > Add suspend and resume callbacks. The priority of these are > > > "_noirq()", to workaround early access to the registers done by the > > > PCI core through the ->read()/->write() callbacks at resume time. > > > > > > Signed-off-by: Miquel Raynal <miquel.raynal@bootlin.com> > > > --- > > > drivers/pci/controller/pci-aardvark.c | 52 +++++++++++++++++++++++++++ > > > 1 file changed, 52 insertions(+) > > > > > > diff --git a/drivers/pci/controller/pci-aardvark.c b/drivers/pci/controller/pci-aardvark.c > > > index 108b3f15c410..7ecf1ac4036b 100644 > > > --- a/drivers/pci/controller/pci-aardvark.c > > > +++ b/drivers/pci/controller/pci-aardvark.c > > > @@ -1108,6 +1108,55 @@ static int advk_pcie_setup_clk(struct advk_pcie *pcie) > > > return ret; > > > } > > > > > > +static int __maybe_unused advk_pcie_suspend(struct device *dev) > > > +{ > > > + struct advk_pcie *pcie = dev_get_drvdata(dev); > > > + > > > + advk_pcie_disable_phy(pcie); > > > + > > > + clk_disable_unprepare(pcie->clk); > > > > I have noticed it is common practice, still, I would like to check whether > > it is allowed to call functions that may sleep in a NOIRQ suspend/resume > > callback ? > > You are right this is weird. I double checked and for instance, > pcie-mediatek.c, pci-tegra.c and pci-imx6.c do the exact same thing. There are > probably other cases where drivers call functions that may sleep from a NOIRQ > context. I am interested to know if this is valid and if not, what is the > alternative? > Yes, it is valid. _noirq means that the high-level action handlers will not be invoked for interrupts occurring during that period, but that doesn't apply to timer interrupts. IOW, don't expect *your* IRQ handler to be invoked then (if this is not a timer IRQ), but you can sleep. Thanks, Rafael
Hi Rafael, Stephen, "Rafael J. Wysocki" <rjw@rjwysocki.net> wrote on Mon, 03 Dec 2018 23:00:20 +0100: > On Monday, December 3, 2018 4:38:46 PM CET Miquel Raynal wrote: > > Hi Lorenzo, > > > > Lorenzo Pieralisi <lorenzo.pieralisi@arm.com> wrote on Mon, 3 Dec 2018 > > 10:27:08 +0000: > > > > > [+Rafael, Sudeep] > > > > > > On Fri, Nov 23, 2018 at 03:18:24PM +0100, Miquel Raynal wrote: > > > > Add suspend and resume callbacks. The priority of these are > > > > "_noirq()", to workaround early access to the registers done by the > > > > PCI core through the ->read()/->write() callbacks at resume time. > > > > > > > > Signed-off-by: Miquel Raynal <miquel.raynal@bootlin.com> > > > > --- > > > > drivers/pci/controller/pci-aardvark.c | 52 +++++++++++++++++++++++++++ > > > > 1 file changed, 52 insertions(+) > > > > > > > > diff --git a/drivers/pci/controller/pci-aardvark.c b/drivers/pci/controller/pci-aardvark.c > > > > index 108b3f15c410..7ecf1ac4036b 100644 > > > > --- a/drivers/pci/controller/pci-aardvark.c > > > > +++ b/drivers/pci/controller/pci-aardvark.c > > > > @@ -1108,6 +1108,55 @@ static int advk_pcie_setup_clk(struct advk_pcie *pcie) > > > > return ret; > > > > } > > > > > > > > +static int __maybe_unused advk_pcie_suspend(struct device *dev) > > > > +{ > > > > + struct advk_pcie *pcie = dev_get_drvdata(dev); > > > > + > > > > + advk_pcie_disable_phy(pcie); > > > > + > > > > + clk_disable_unprepare(pcie->clk); > > > > > > I have noticed it is common practice, still, I would like to check whether > > > it is allowed to call functions that may sleep in a NOIRQ suspend/resume > > > callback ? > > > > You are right this is weird. I double checked and for instance, > > pcie-mediatek.c, pci-tegra.c and pci-imx6.c do the exact same thing. There are > > probably other cases where drivers call functions that may sleep from a NOIRQ > > context. I am interested to know if this is valid and if not, what is the > > alternative? > > > > Yes, it is valid. _noirq means that the high-level action handlers will not be > invoked for interrupts occurring during that period, but that doesn't apply to > timer interrupts. > > IOW, don't expect *your* IRQ handler to be invoked then (if this is not a timer > IRQ), but you can sleep. > > Thanks, > Rafael > Thank you both for the enlightenment. Thanks, Miquèl
On Mon, Dec 03, 2018 at 11:00:20PM +0100, Rafael J. Wysocki wrote: > On Monday, December 3, 2018 4:38:46 PM CET Miquel Raynal wrote: > > Hi Lorenzo, > > > > Lorenzo Pieralisi <lorenzo.pieralisi@arm.com> wrote on Mon, 3 Dec 2018 > > 10:27:08 +0000: > > > > > [+Rafael, Sudeep] > > > > > > On Fri, Nov 23, 2018 at 03:18:24PM +0100, Miquel Raynal wrote: > > > > Add suspend and resume callbacks. The priority of these are > > > > "_noirq()", to workaround early access to the registers done by the > > > > PCI core through the ->read()/->write() callbacks at resume time. > > > > > > > > Signed-off-by: Miquel Raynal <miquel.raynal@bootlin.com> > > > > --- > > > > drivers/pci/controller/pci-aardvark.c | 52 +++++++++++++++++++++++++++ > > > > 1 file changed, 52 insertions(+) > > > > > > > > diff --git a/drivers/pci/controller/pci-aardvark.c b/drivers/pci/controller/pci-aardvark.c > > > > index 108b3f15c410..7ecf1ac4036b 100644 > > > > --- a/drivers/pci/controller/pci-aardvark.c > > > > +++ b/drivers/pci/controller/pci-aardvark.c > > > > @@ -1108,6 +1108,55 @@ static int advk_pcie_setup_clk(struct advk_pcie *pci > > > > return ret; > > > > } > > > > > > > > +static int __maybe_unused advk_pcie_suspend(struct device *dev) > > > > +{ > > > > + struct advk_pcie *pcie = dev_get_drvdata(dev); > > > > + > > > > + advk_pcie_disable_phy(pcie); > > > > + > > > > + clk_disable_unprepare(pcie->clk); > > > > > > I have noticed it is common practice, still, I would like to check whether > > > it is allowed to call functions that may sleep in a NOIRQ suspend/resume > > > callback ? > > > > You are right this is weird. I double checked and for instance, > > pcie-mediatek.c, pci-tegra.c and pci-imx6.c do the exact same thing. There are > > probably other cases where drivers call functions that may sleep from a NOIRQ > > context. I am interested to know if this is valid and if not, what is the > > alternative? > > > > Yes, it is valid. _noirq means that the high-level action handlers > will not be invoked for interrupts occurring during that period, but > that doesn't apply to timer interrupts. > > IOW, don't expect *your* IRQ handler to be invoked then (if this is > not a timer IRQ), but you can sleep. Hi Rafael, all, I did not ask my question (that may be silly) properly apologies. I know that the S2R context allows sleeping the question is, in case clk_disable_unprepare() (and resume counterparts) sleeps, what is going to wake it up, given that we are in the S2R NOIRQ phase and as you said the action handlers (that are possibly required to wake up the eg clk_disable_unprepare() caller) are disabled (unless, AFAIK, IRQF_NO_SUSPEND is passed at IRQ request time in the respective driver). The clk API implementations back-ends are beyond my depth, I just wanted to make sure I understand how the S2R flow is expected to work in this specific case. Thanks, Lorenzo
On Tuesday, December 4, 2018 10:45:58 AM CET Lorenzo Pieralisi wrote: > On Mon, Dec 03, 2018 at 11:00:20PM +0100, Rafael J. Wysocki wrote: > > On Monday, December 3, 2018 4:38:46 PM CET Miquel Raynal wrote: > > > Hi Lorenzo, > > > > > > Lorenzo Pieralisi <lorenzo.pieralisi@arm.com> wrote on Mon, 3 Dec 2018 > > > 10:27:08 +0000: > > > > > > > [+Rafael, Sudeep] > > > > > > > > On Fri, Nov 23, 2018 at 03:18:24PM +0100, Miquel Raynal wrote: > > > > > Add suspend and resume callbacks. The priority of these are > > > > > "_noirq()", to workaround early access to the registers done by the > > > > > PCI core through the ->read()/->write() callbacks at resume time. > > > > > > > > > > Signed-off-by: Miquel Raynal <miquel.raynal@bootlin.com> > > > > > --- > > > > > drivers/pci/controller/pci-aardvark.c | 52 +++++++++++++++++++++++++++ > > > > > 1 file changed, 52 insertions(+) > > > > > > > > > > diff --git a/drivers/pci/controller/pci-aardvark.c b/drivers/pci/controller/pci-aardvark.c > > > > > index 108b3f15c410..7ecf1ac4036b 100644 > > > > > --- a/drivers/pci/controller/pci-aardvark.c > > > > > +++ b/drivers/pci/controller/pci-aardvark.c > > > > > @@ -1108,6 +1108,55 @@ static int advk_pcie_setup_clk(struct advk_pcie *pci > > > > > return ret; > > > > > } > > > > > > > > > > +static int __maybe_unused advk_pcie_suspend(struct device *dev) > > > > > +{ > > > > > + struct advk_pcie *pcie = dev_get_drvdata(dev); > > > > > + > > > > > + advk_pcie_disable_phy(pcie); > > > > > + > > > > > + clk_disable_unprepare(pcie->clk); > > > > > > > > I have noticed it is common practice, still, I would like to check whether > > > > it is allowed to call functions that may sleep in a NOIRQ suspend/resume > > > > callback ? > > > > > > You are right this is weird. I double checked and for instance, > > > pcie-mediatek.c, pci-tegra.c and pci-imx6.c do the exact same thing. There are > > > probably other cases where drivers call functions that may sleep from a NOIRQ > > > context. I am interested to know if this is valid and if not, what is the > > > alternative? > > > > > > > Yes, it is valid. _noirq means that the high-level action handlers > > will not be invoked for interrupts occurring during that period, but > > that doesn't apply to timer interrupts. > > > > IOW, don't expect *your* IRQ handler to be invoked then (if this is > > not a timer IRQ), but you can sleep. > > Hi Rafael, all, > > I did not ask my question (that may be silly) properly apologies. I know > that the S2R context allows sleeping the question is, in case > clk_disable_unprepare() (and resume counterparts) sleeps, If it just sleeps, then this is not a problem, but if it actually *waits* for something meaningful to happen (which I guess is what you really mean), then things may go awry. > what is going to wake it up, given that we are in the S2R NOIRQ phase and as > you said the action handlers (that are possibly required to wake up the eg > clk_disable_unprepare() caller) are disabled (unless, AFAIK, > IRQF_NO_SUSPEND is passed at IRQ request time in the respective driver). So if it waits for an action handler to do something and wake it up, it may very well deadlock. I have no idea if that really happens, though. > The clk API implementations back-ends are beyond my depth, I just wanted > to make sure I understand how the S2R flow is expected to work in this > specific case. Action handlers won't run unless the IRQs are marked as IRQF_NO_SUSPEND (well, there are a few more complications I don't recall exactly, but that's the basic rule). If anything depends on them to run, it will block. Thanks, Rafael
On Tue, Dec 04, 2018 at 10:42:19PM +0100, Rafael J. Wysocki wrote: > On Tuesday, December 4, 2018 10:45:58 AM CET Lorenzo Pieralisi wrote: > > On Mon, Dec 03, 2018 at 11:00:20PM +0100, Rafael J. Wysocki wrote: > > > On Monday, December 3, 2018 4:38:46 PM CET Miquel Raynal wrote: > > > > Hi Lorenzo, > > > > > > > > Lorenzo Pieralisi <lorenzo.pieralisi@arm.com> wrote on Mon, 3 Dec 2018 > > > > 10:27:08 +0000: > > > > > > > > > [+Rafael, Sudeep] > > > > > > > > > > On Fri, Nov 23, 2018 at 03:18:24PM +0100, Miquel Raynal wrote: > > > > > > Add suspend and resume callbacks. The priority of these are > > > > > > "_noirq()", to workaround early access to the registers done by the > > > > > > PCI core through the ->read()/->write() callbacks at resume time. > > > > > > > > > > > > Signed-off-by: Miquel Raynal <miquel.raynal@bootlin.com> > > > > > > --- > > > > > > drivers/pci/controller/pci-aardvark.c | 52 +++++++++++++++++++++++++++ > > > > > > 1 file changed, 52 insertions(+) > > > > > > > > > > > > diff --git a/drivers/pci/controller/pci-aardvark.c b/drivers/pci/controller/pci-aardvark.c > > > > > > index 108b3f15c410..7ecf1ac4036b 100644 > > > > > > --- a/drivers/pci/controller/pci-aardvark.c > > > > > > +++ b/drivers/pci/controller/pci-aardvark.c > > > > > > @@ -1108,6 +1108,55 @@ static int advk_pcie_setup_clk(struct advk_pcie *pci > > > > > > return ret; > > > > > > } > > > > > > > > > > > > +static int __maybe_unused advk_pcie_suspend(struct device *dev) > > > > > > +{ > > > > > > + struct advk_pcie *pcie = dev_get_drvdata(dev); > > > > > > + > > > > > > + advk_pcie_disable_phy(pcie); > > > > > > + > > > > > > + clk_disable_unprepare(pcie->clk); > > > > > > > > > > I have noticed it is common practice, still, I would like to check whether > > > > > it is allowed to call functions that may sleep in a NOIRQ suspend/resume > > > > > callback ? > > > > > > > > You are right this is weird. I double checked and for instance, > > > > pcie-mediatek.c, pci-tegra.c and pci-imx6.c do the exact same thing. There are > > > > probably other cases where drivers call functions that may sleep from a NOIRQ > > > > context. I am interested to know if this is valid and if not, what is the > > > > alternative? > > > > > > > > > > Yes, it is valid. _noirq means that the high-level action handlers > > > will not be invoked for interrupts occurring during that period, but > > > that doesn't apply to timer interrupts. > > > > > > IOW, don't expect *your* IRQ handler to be invoked then (if this is > > > not a timer IRQ), but you can sleep. > > > > Hi Rafael, all, > > > > I did not ask my question (that may be silly) properly apologies. I know > > that the S2R context allows sleeping the question is, in case > > clk_disable_unprepare() (and resume counterparts) sleeps, > > If it just sleeps, then this is not a problem, but if it actually *waits* > for something meaningful to happen (which I guess is what you really mean), > then things may go awry. That's what I meant and I assume that's reason why the *_prepare/unprepare() API are allowed to sleep, waiting for an event to trigger. > > what is going to wake it up, given that we are in the S2R NOIRQ phase and as > > you said the action handlers (that are possibly required to wake up the eg > > clk_disable_unprepare() caller) are disabled (unless, AFAIK, > > IRQF_NO_SUSPEND is passed at IRQ request time in the respective driver). > > So if it waits for an action handler to do something and wake it up, it may > very well deadlock. I have no idea if that really happens, though. I have no idea either, that's why I asked the clock maintainers too, the point is, the clk API allows this behaviour, I do not think it is safe to rely on a non-blocking clk back-end, that's why I raised the question in the first place. > > The clk API implementations back-ends are beyond my depth, I just wanted > > to make sure I understand how the S2R flow is expected to work in this > > specific case. > > Action handlers won't run unless the IRQs are marked as IRQF_NO_SUSPEND > (well, there are a few more complications I don't recall exactly, but > that's the basic rule). If anything depends on them to run, it will block. It looks like this patch (and more code in the kernel) expects either the clk calls not to block or the action handler implemented in the clock back-ends to run in S2R-NOIRQ (possibly by using the IRQF_NO_SUSPEND flag). I would appreciate if the clock maintainers can shed some light on this. Thanks, Lorenzo
On Tue, Dec 04, 2018 at 10:42:19PM +0100, Rafael J. Wysocki wrote: > On Tuesday, December 4, 2018 10:45:58 AM CET Lorenzo Pieralisi wrote: > > On Mon, Dec 03, 2018 at 11:00:20PM +0100, Rafael J. Wysocki wrote: > > > On Monday, December 3, 2018 4:38:46 PM CET Miquel Raynal wrote: > > > > Hi Lorenzo, > > > > > > > > Lorenzo Pieralisi <lorenzo.pieralisi@arm.com> wrote on Mon, 3 Dec 2018 > > > > 10:27:08 +0000: > > > > > > > > > [+Rafael, Sudeep] > > > > > > > > > > On Fri, Nov 23, 2018 at 03:18:24PM +0100, Miquel Raynal wrote: > > > > > > Add suspend and resume callbacks. The priority of these are > > > > > > "_noirq()", to workaround early access to the registers done by the > > > > > > PCI core through the ->read()/->write() callbacks at resume time. > > > > > > > > > > > > Signed-off-by: Miquel Raynal <miquel.raynal@bootlin.com> > > > > > > --- > > > > > > drivers/pci/controller/pci-aardvark.c | 52 +++++++++++++++++++++++++++ > > > > > > 1 file changed, 52 insertions(+) > > > > > > > > > > > > diff --git a/drivers/pci/controller/pci-aardvark.c b/drivers/pci/controller/pci-aardvark.c > > > > > > index 108b3f15c410..7ecf1ac4036b 100644 > > > > > > --- a/drivers/pci/controller/pci-aardvark.c > > > > > > +++ b/drivers/pci/controller/pci-aardvark.c > > > > > > @@ -1108,6 +1108,55 @@ static int advk_pcie_setup_clk(struct advk_pcie *pci > > > > > > return ret; > > > > > > } > > > > > > > > > > > > +static int __maybe_unused advk_pcie_suspend(struct device *dev) > > > > > > +{ > > > > > > + struct advk_pcie *pcie = dev_get_drvdata(dev); > > > > > > + > > > > > > + advk_pcie_disable_phy(pcie); > > > > > > + > > > > > > + clk_disable_unprepare(pcie->clk); > > > > > > > > > > I have noticed it is common practice, still, I would like to check whether > > > > > it is allowed to call functions that may sleep in a NOIRQ suspend/resume > > > > > callback ? > > > > > > > > You are right this is weird. I double checked and for instance, > > > > pcie-mediatek.c, pci-tegra.c and pci-imx6.c do the exact same thing. There are > > > > probably other cases where drivers call functions that may sleep from a NOIRQ > > > > context. I am interested to know if this is valid and if not, what is the > > > > alternative? > > > > > > > > > > Yes, it is valid. _noirq means that the high-level action handlers > > > will not be invoked for interrupts occurring during that period, but > > > that doesn't apply to timer interrupts. > > > > > > IOW, don't expect *your* IRQ handler to be invoked then (if this is > > > not a timer IRQ), but you can sleep. > > > > Hi Rafael, all, > > > > I did not ask my question (that may be silly) properly apologies. I know > > that the S2R context allows sleeping the question is, in case > > clk_disable_unprepare() (and resume counterparts) sleeps, > > If it just sleeps, then this is not a problem, but if it actually *waits* > for something meaningful to happen (which I guess is what you really mean), > then things may go awry. > > > what is going to wake it up, given that we are in the S2R NOIRQ phase and as > > you said the action handlers (that are possibly required to wake up the eg > > clk_disable_unprepare() caller) are disabled (unless, AFAIK, > > IRQF_NO_SUSPEND is passed at IRQ request time in the respective driver). > > So if it waits for an action handler to do something and wake it up, it may > very well deadlock. I have no idea if that really happens, though. > > > The clk API implementations back-ends are beyond my depth, I just wanted > > to make sure I understand how the S2R flow is expected to work in this > > specific case. > > Action handlers won't run unless the IRQs are marked as IRQF_NO_SUSPEND > (well, there are a few more complications I don't recall exactly, but > that's the basic rule). If anything depends on them to run, it will block. Stephen, any comments on this ? I would like to understand if it is safe to call a clk_*unprepare/prepare_* function (that may have a blocking back-end waiting on a wake-up event triggered by an IRQ action) in the suspend/resume NOIRQ phase. It is not clear how the unprepare/prepare() callers can possibly know whether it is safe to block at that stage given that IRQ actions are suspended and the wake-up may never trigger. Thanks, Lorenzo
Quoting Lorenzo Pieralisi (2018-12-11 06:16:27) > On Tue, Dec 04, 2018 at 10:42:19PM +0100, Rafael J. Wysocki wrote: > > On Tuesday, December 4, 2018 10:45:58 AM CET Lorenzo Pieralisi wrote: > > > On Mon, Dec 03, 2018 at 11:00:20PM +0100, Rafael J. Wysocki wrote: > > > > On Monday, December 3, 2018 4:38:46 PM CET Miquel Raynal wrote: > > > > > > I did not ask my question (that may be silly) properly apologies. I know > > > that the S2R context allows sleeping the question is, in case > > > clk_disable_unprepare() (and resume counterparts) sleeps, > > > > If it just sleeps, then this is not a problem, but if it actually *waits* > > for something meaningful to happen (which I guess is what you really mean), > > then things may go awry. > > > > > what is going to wake it up, given that we are in the S2R NOIRQ phase and as > > > you said the action handlers (that are possibly required to wake up the eg > > > clk_disable_unprepare() caller) are disabled (unless, AFAIK, > > > IRQF_NO_SUSPEND is passed at IRQ request time in the respective driver). > > > > So if it waits for an action handler to do something and wake it up, it may > > very well deadlock. I have no idea if that really happens, though. > > > > > The clk API implementations back-ends are beyond my depth, I just wanted > > > to make sure I understand how the S2R flow is expected to work in this > > > specific case. > > > > Action handlers won't run unless the IRQs are marked as IRQF_NO_SUSPEND > > (well, there are a few more complications I don't recall exactly, but > > that's the basic rule). If anything depends on them to run, it will block. > > Stephen, any comments on this ? Sorry I seemed to miss this email. BTW, what is an "action handler" here? The IRQ action handler? > I would like to understand if it is safe > to call a clk_*unprepare/prepare_* function (that may have a blocking > back-end waiting on a wake-up event triggered by an IRQ action) in the > suspend/resume NOIRQ phase. Does this ever occur in practice? I imagine "blocking back-end waiting on a wake-up event" would be some sort of i2c or SPI based "slow" clk that is prepared/unprepared in the NOIRQ phase of suspend/resume? So that function call into the clk API fails because the i2c or SPI controller used to toggle the clk on/off state relies on the controller's IRQ to manage the transaction over the bus but that IRQ is disabled. I suppose this is possible but I've never heard of it happening in practice. Do you have such a scenario? > > It is not clear how the unprepare/prepare() callers can possibly know > whether it is safe to block at that stage given that IRQ actions are > suspended and the wake-up may never trigger. > Is this solved in other situations somehow? I don't think clk consumers have any idea that things are safe or not safe to use in the NOIRQ phase of suspend, but I also don't see how clks are special here. Any provider consumer pattern would fall into the same trap, but maybe clks are the first ones to get here. It seems like a larger problem with NOIRQ suspend in general and how it is too coarse of a solution for suspend ordering of devices. It's not like we need *all* device interrupts to be disabled to do something in suspend with one particular device. Most likely, we just need the device and all it's children to be suspended and this device to have it's IRQ disabled for the NOIRQ suspend callback to work. (Maybe any devices it's supplying with device links too?) If that's really the case, then I can see how one device and it's children are suspended and the irq for it is disabled but the providing devices (clk, regulator, bus controller, etc.) are still fully active and not suspended but in fact completely usable and able to service interrupts. If that all makes sense, then I would answer the question with a definitive "yes it's all fine" because the clk consumer could be in the NOIRQ phase of its suspend but the clk provider wouldn't have even started suspending yet when clk_disable_unprepare() is called.
On Thu, Dec 13, 2018 at 01:00:26AM -0800, Stephen Boyd wrote: > Quoting Lorenzo Pieralisi (2018-12-11 06:16:27) > > On Tue, Dec 04, 2018 at 10:42:19PM +0100, Rafael J. Wysocki wrote: > > > On Tuesday, December 4, 2018 10:45:58 AM CET Lorenzo Pieralisi wrote: > > > > On Mon, Dec 03, 2018 at 11:00:20PM +0100, Rafael J. Wysocki wrote: > > > > > On Monday, December 3, 2018 4:38:46 PM CET Miquel Raynal wrote: > > > > > > > > I did not ask my question (that may be silly) properly apologies. I know > > > > that the S2R context allows sleeping the question is, in case > > > > clk_disable_unprepare() (and resume counterparts) sleeps, > > > > > > If it just sleeps, then this is not a problem, but if it actually *waits* > > > for something meaningful to happen (which I guess is what you really mean), > > > then things may go awry. > > > > > > > what is going to wake it up, given that we are in the S2R NOIRQ phase and as > > > > you said the action handlers (that are possibly required to wake up the eg > > > > clk_disable_unprepare() caller) are disabled (unless, AFAIK, > > > > IRQF_NO_SUSPEND is passed at IRQ request time in the respective driver). > > > > > > So if it waits for an action handler to do something and wake it up, it may > > > very well deadlock. I have no idea if that really happens, though. > > > > > > > The clk API implementations back-ends are beyond my depth, I just wanted > > > > to make sure I understand how the S2R flow is expected to work in this > > > > specific case. > > > > > > Action handlers won't run unless the IRQs are marked as IRQF_NO_SUSPEND > > > (well, there are a few more complications I don't recall exactly, but > > > that's the basic rule). If anything depends on them to run, it will block. > > > > Stephen, any comments on this ? > > Sorry I seemed to miss this email. BTW, what is an "action handler" > here? The IRQ action handler? Yes, that is. > > I would like to understand if it is safe > > to call a clk_*unprepare/prepare_* function (that may have a blocking > > back-end waiting on a wake-up event triggered by an IRQ action) in the > > suspend/resume NOIRQ phase. > > Does this ever occur in practice? I imagine "blocking back-end waiting > on a wake-up event" would be some sort of i2c or SPI based "slow" clk > that is prepared/unprepared in the NOIRQ phase of suspend/resume? So > that function call into the clk API fails because the i2c or SPI > controller used to toggle the clk on/off state relies on the > controller's IRQ to manage the transaction over the bus but that IRQ is > disabled. I suppose this is possible but I've never heard of it > happening in practice. Do you have such a scenario? No (because my knowledge of clock internals is poor) but I questioned the code while reviewing it - I do not think it is a safe assumption to make (otherwise what's the purpose of having a clk API - *prepare/unprepare*() - that, AFAIK was implemented to allow back-ends to block, waiting for an event). There is clearly an implicit assumption there from clk API caller POW "this call won't block or an IRQ action - IRQF_NO_SUSPEND - will wake me up if it does. Or the call can time out, but that's an error path". This seems fragile to me. > > It is not clear how the unprepare/prepare() callers can possibly know > > whether it is safe to block at that stage given that IRQ actions are > > suspended and the wake-up may never trigger. > > > > Is this solved in other situations somehow? I don't think clk consumers > have any idea that things are safe or not safe to use in the NOIRQ phase > of suspend, but I also don't see how clks are special here. Any provider > consumer pattern would fall into the same trap, but maybe clks are the > first ones to get here. You have a good point, I do not think clk are specials, I am only saying this patch code can run into significant issues. > It seems like a larger problem with NOIRQ suspend in general and how it > is too coarse of a solution for suspend ordering of devices. It's not > like we need *all* device interrupts to be disabled to do something in > suspend with one particular device. Most likely, we just need the device > and all it's children to be suspended and this device to have it's IRQ > disabled for the NOIRQ suspend callback to work. (Maybe any devices it's > supplying with device links too?) > > If that's really the case, then I can see how one device and it's > children are suspended and the irq for it is disabled but the providing > devices (clk, regulator, bus controller, etc.) are still fully active > and not suspended but in fact completely usable and able to service > interrupts. If that all makes sense, then I would answer the question > with a definitive "yes it's all fine" because the clk consumer could be > in the NOIRQ phase of its suspend but the clk provider wouldn't have > even started suspending yet when clk_disable_unprepare() is called. That's a very good summary and address my concern, I still question this patch correctness (and many others that carry out clk operations in S2R NOIRQ phase), they may work but do not tell me they are rock solid given your accurate summary above. Thanks, Lorenzo
Hi Lorenzo, > > If that's really the case, then I can see how one device and it's > > children are suspended and the irq for it is disabled but the providing > > devices (clk, regulator, bus controller, etc.) are still fully active > > and not suspended but in fact completely usable and able to service > > interrupts. If that all makes sense, then I would answer the question > > with a definitive "yes it's all fine" because the clk consumer could be > > in the NOIRQ phase of its suspend but the clk provider wouldn't have > > even started suspending yet when clk_disable_unprepare() is called. > > That's a very good summary and address my concern, I still question this > patch correctness (and many others that carry out clk operations in S2R > NOIRQ phase), they may work but do not tell me they are rock solid given > your accurate summary above. I understand your concern but I don't see any alternative right now and a deep rework of the PM core to respect such dependency is not something that can be done in a reasonable amount of time. With regard to this constraint, do you think it is worth blocking the series? Thanks, Miquèl
On Thu, Dec 13, 2018 at 03:30:00PM +0100, Miquel Raynal wrote: > Hi Lorenzo, > > > > If that's really the case, then I can see how one device and it's > > > children are suspended and the irq for it is disabled but the providing > > > devices (clk, regulator, bus controller, etc.) are still fully active > > > and not suspended but in fact completely usable and able to service > > > interrupts. If that all makes sense, then I would answer the question > > > with a definitive "yes it's all fine" because the clk consumer could be > > > in the NOIRQ phase of its suspend but the clk provider wouldn't have > > > even started suspending yet when clk_disable_unprepare() is called. > > > > That's a very good summary and address my concern, I still question this > > patch correctness (and many others that carry out clk operations in S2R > > NOIRQ phase), they may work but do not tell me they are rock solid given > > your accurate summary above. > > I understand your concern but I don't see any alternative right now > and a deep rework of the PM core to respect such dependency is not > something that can be done in a reasonable amount of time. With > regard to this constraint, do you think it is worth blocking the > series? I think we agree that, depending on what HW/SW driver manage this PCI controller clocks, this driver may well become broken, the driver itself has no idea what's behind the clock API and can end up waiting for an event forever. This does not leave me in a comfortable position to merge code that I know has flaws. I won't merge it for v4.21, I need more time (and feedback) to understand what can be done to make this driver (and many others) more robust. Thanks, Lorenzo
On Thursday, December 13, 2018 3:30:00 PM CET Miquel Raynal wrote: > Hi Lorenzo, > > > > If that's really the case, then I can see how one device and it's > > > children are suspended and the irq for it is disabled but the providing > > > devices (clk, regulator, bus controller, etc.) are still fully active > > > and not suspended but in fact completely usable and able to service > > > interrupts. If that all makes sense, then I would answer the question > > > with a definitive "yes it's all fine" because the clk consumer could be > > > in the NOIRQ phase of its suspend but the clk provider wouldn't have > > > even started suspending yet when clk_disable_unprepare() is called. > > > > That's a very good summary and address my concern, I still question this > > patch correctness (and many others that carry out clk operations in S2R > > NOIRQ phase), they may work but do not tell me they are rock solid given > > your accurate summary above. > > I understand your concern but I don't see any alternative right now > and a deep rework of the PM core to respect such dependency is not > something that can be done in a reasonable amount of time. Maybe you don't need to rework anything. :-) Have you considered using device links? Thanks, Rafael
Hi Rafael, "Rafael J. Wysocki" <rjw@rjwysocki.net> wrote on Thu, 13 Dec 2018 22:50:51 +0100: > On Thursday, December 13, 2018 3:30:00 PM CET Miquel Raynal wrote: > > Hi Lorenzo, > > > > > > If that's really the case, then I can see how one device and it's > > > > children are suspended and the irq for it is disabled but the providing > > > > devices (clk, regulator, bus controller, etc.) are still fully active > > > > and not suspended but in fact completely usable and able to service > > > > interrupts. If that all makes sense, then I would answer the question > > > > with a definitive "yes it's all fine" because the clk consumer could be > > > > in the NOIRQ phase of its suspend but the clk provider wouldn't have > > > > even started suspending yet when clk_disable_unprepare() is called. > > > > > > That's a very good summary and address my concern, I still question this > > > patch correctness (and many others that carry out clk operations in S2R > > > NOIRQ phase), they may work but do not tell me they are rock solid given > > > your accurate summary above. > > > > I understand your concern but I don't see any alternative right now > > and a deep rework of the PM core to respect such dependency is not > > something that can be done in a reasonable amount of time. > > Maybe you don't need to rework anything. :-) > > Have you considered using device links? Absolutely, yes :) I am actively working on it in parallel, you can check the third version there [1]. Stephen Boyd has a slightly different idea of how it should be done, I will propose a v4 this week, I can add you in copy if you are interested! Anyway, there is one thing that is still missing: * Let's have device A that requests clock B * With the device link series, A is linked (as a child) to B. * A suspend/resume hooks handle things in the NOIRQ phase. * B suspend/resume hooks handle things in the default phase. What I expected during a suspend: 1/ ->suspend_noirq(device A) 2/ ->suspend(clock B) Unfortunately, device links do not seem to enforce any priority between phases (default/late/noirq) and what happens is: 1/ ->suspend(B) 2/ ->suspend_noirq(A) Which has no sense in my case. Hence, I had to request the clock suspend/resume callbacks to be upgraded to the NOIRQ phase as well (I don't have a better solution for now). This is still under discussion in a thread you have been recently added to by Bjorn, see [2]. So when I told you I was not confident in "reworking the PM core to respect such dependency", this is what I was referring to. I am definitely ready to help, but I don't feel I can do it alone. [1] https://www.spinics.net/lists/linux-clk/msg32824.html [2] https://marc.info/?l=linux-pm&m=154465198510735&w=2 Thanks, Miquèl
On Monday, December 17, 2018 3:54:26 PM CET Miquel Raynal wrote: > Hi Rafael, > > "Rafael J. Wysocki" <rjw@rjwysocki.net> wrote on Thu, 13 Dec 2018 > 22:50:51 +0100: > > > On Thursday, December 13, 2018 3:30:00 PM CET Miquel Raynal wrote: > > > Hi Lorenzo, > > > > > > > > If that's really the case, then I can see how one device and it's > > > > > children are suspended and the irq for it is disabled but the providing > > > > > devices (clk, regulator, bus controller, etc.) are still fully active > > > > > and not suspended but in fact completely usable and able to service > > > > > interrupts. If that all makes sense, then I would answer the question > > > > > with a definitive "yes it's all fine" because the clk consumer could be > > > > > in the NOIRQ phase of its suspend but the clk provider wouldn't have > > > > > even started suspending yet when clk_disable_unprepare() is called. > > > > > > > > That's a very good summary and address my concern, I still question this > > > > patch correctness (and many others that carry out clk operations in S2R > > > > NOIRQ phase), they may work but do not tell me they are rock solid given > > > > your accurate summary above. > > > > > > I understand your concern but I don't see any alternative right now > > > and a deep rework of the PM core to respect such dependency is not > > > something that can be done in a reasonable amount of time. > > > > Maybe you don't need to rework anything. :-) > > > > Have you considered using device links? > > Absolutely, yes :) I am actively working on it in parallel, you can > check the third version there [1]. Stephen Boyd has a slightly > different idea of how it should be done, I will propose a v4 this week, > I can add you in copy if you are interested! > > Anyway, there is one thing that is still missing: > * Let's have device A that requests clock B > * With the device link series, A is linked (as a child) to B. > * A suspend/resume hooks handle things in the NOIRQ phase. Why do you need them to run in the "noirq" phase in the first place? > * B suspend/resume hooks handle things in the default phase. > > What I expected during a suspend: > 1/ ->suspend_noirq(device A) > 2/ ->suspend(clock B) This expectation is not in agreement with the documented suspend code flow, however. Each phase of it is carried out for *all* devices completely before getting to the next phase, "prepare" first, then "suspend", "suspend_late" and "suspend_noirq", in this order. > Unfortunately, device links do not seem to enforce any priority between > phases (default/late/noirq) and what happens is: > 1/ ->suspend(B) > 2/ ->suspend_noirq(A) > Which has no sense in my case. Hence, I had to request the clock > suspend/resume callbacks to be upgraded to the NOIRQ phase as well (I > don't have a better solution for now). This is still under discussion > in a thread you have been recently added to by Bjorn, see [2]. > > So when I told you I was not confident in "reworking the PM core to > respect such dependency", this is what I was referring to. I am > definitely ready to help, but I don't feel I can do it alone. > > [1] https://www.spinics.net/lists/linux-clk/msg32824.html > [2] https://marc.info/?l=linux-pm&m=154465198510735&w=2 The rework you seem to be talking about is not possible, I'm afraid.
Hi Rafael, Stephen & Bjorn,
Glad to see you all in this thread that talks about:
* adding S2RAM support to a PCIe controller driver
* by taking into account that the PCI clock must be
{enabled before,disabled after} the PCI IP itself
* and that it requires some tweaking in the clock driver to
promote the suspend/resume() callbacks to the NOIRQ phase
(reference there [1]).
Stephen, Rafael answered here to your remark (in thread [1]) about the
NOIRQ promotion (see below).
Bjorn, there is a question for you below about the need for a PCI
controller driver to suspend/resume in the NOIRQ phase.
Rafael, thanks for the explanation of what the PM core sequences really
are, I would need you to confirm my approach that promotes the clock
suspend/resume() callbacks to the NOIRQ phase, or otherwise give me
pointers to an alternate solution (also below).
"Rafael J. Wysocki" <rjw@rjwysocki.net> wrote on Tue, 18 Dec 2018
11:54:43 +0100:
> On Monday, December 17, 2018 3:54:26 PM CET Miquel Raynal wrote:
> > Hi Rafael,
> >
> > "Rafael J. Wysocki" <rjw@rjwysocki.net> wrote on Thu, 13 Dec 2018
> > 22:50:51 +0100:
> >
> > > On Thursday, December 13, 2018 3:30:00 PM CET Miquel Raynal wrote:
> > > > Hi Lorenzo,
> > > >
> > > > > > If that's really the case, then I can see how one device and it's
> > > > > > children are suspended and the irq for it is disabled but the providing
> > > > > > devices (clk, regulator, bus controller, etc.) are still fully active
> > > > > > and not suspended but in fact completely usable and able to service
> > > > > > interrupts. If that all makes sense, then I would answer the question
> > > > > > with a definitive "yes it's all fine" because the clk consumer could be
> > > > > > in the NOIRQ phase of its suspend but the clk provider wouldn't have
> > > > > > even started suspending yet when clk_disable_unprepare() is called.
> > > > >
> > > > > That's a very good summary and address my concern, I still question this
> > > > > patch correctness (and many others that carry out clk operations in S2R
> > > > > NOIRQ phase), they may work but do not tell me they are rock solid given
> > > > > your accurate summary above.
> > > >
> > > > I understand your concern but I don't see any alternative right now
> > > > and a deep rework of the PM core to respect such dependency is not
> > > > something that can be done in a reasonable amount of time.
> > >
> > > Maybe you don't need to rework anything. :-)
> > >
> > > Have you considered using device links?
> >
> > Absolutely, yes :) I am actively working on it in parallel, you can
> > check the third version there [1]. Stephen Boyd has a slightly
> > different idea of how it should be done, I will propose a v4 this week,
> > I can add you in copy if you are interested!
> >
> > Anyway, there is one thing that is still missing:
> > * Let's have device A that requests clock B
> > * With the device link series, A is linked (as a child) to B.
> > * A suspend/resume hooks handle things in the NOIRQ phase.
>
> Why do you need them to run in the "noirq" phase in the first place?
I suppose (and I would like Bjorn to validate my thoughts) that this
is a limitation imposed by the PCI core, as described in this
commit:
commit ab14d45ea58eae67c739e4ba01871cae7b6c4586
Author: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
Date: Tue Mar 17 15:55:45 2015 +0100
PCI: mvebu: Add suspend/resume support
Add suspend/resume support for the mvebu PCIe host driver. Without this
commit, the system will panic at resume time when PCIe devices are
connected.
Note that we have to use the ->suspend_noirq() and ->resume_noirq() hooks,
because at resume time, the PCI fixups are done at ->resume_noirq() time,
so the PCIe controller has to be ready at this point.
Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
Acked-by: Jason Cooper <jason@lakedaemon.net>
>
> > * B suspend/resume hooks handle things in the default phase.
> >
> > What I expected during a suspend:
> > 1/ ->suspend_noirq(device A)
> > 2/ ->suspend(clock B)
>
> This expectation is not in agreement with the documented suspend code flow,
> however.
>
> Each phase of it is carried out for *all* devices completely before getting
> to the next phase, "prepare" first, then "suspend", "suspend_late" and
> "suspend_noirq", in this order.
Thanks for clarifying, now it is clear and it also answers Stephen
remark in the related thread [1]:
[PATCH 2/4] clk: mvebu: armada-37xx-periph: change
suspend/resume time
Stephen, said:
"This seems sad that the PM core can't "priority boost" any
suspend/resume callbacks of a device that doesn't have noirq callbacks
when a device that depends on it from the device link perspective does
have noirq callbacks."
>
> > Unfortunately, device links do not seem to enforce any priority between
> > phases (default/late/noirq) and what happens is:
> > 1/ ->suspend(B)
> > 2/ ->suspend_noirq(A)
> > Which has no sense in my case. Hence, I had to request the clock
> > suspend/resume callbacks to be upgraded to the NOIRQ phase as well (I
> > don't have a better solution for now). This is still under discussion
> > in a thread you have been recently added to by Bjorn, see [2].
> >
> > So when I told you I was not confident in "reworking the PM core to
> > respect such dependency", this is what I was referring to. I am
> > definitely ready to help, but I don't feel I can do it alone.
> >
> > [1] https://www.spinics.net/lists/linux-clk/msg32824.html
> > [2] https://marc.info/?l=linux-pm&m=154465198510735&w=2
>
> The rework you seem to be talking about is not possible, I'm afraid.
>
Ok, then do you agree that the only solution in this case is what I
propose in thread [1], ie. promoting the clock suspend/resume callbacks
to the NOIRQ phase in order to ensure that they will run first (once
device links will be merged too) ?
[1] https://www.spinics.net/lists/linux-clk/msg32537.html
Thank you very much for helping,
Miquèl
diff --git a/drivers/pci/controller/pci-aardvark.c b/drivers/pci/controller/pci-aardvark.c index 108b3f15c410..7ecf1ac4036b 100644 --- a/drivers/pci/controller/pci-aardvark.c +++ b/drivers/pci/controller/pci-aardvark.c @@ -1108,6 +1108,55 @@ static int advk_pcie_setup_clk(struct advk_pcie *pcie) return ret; } +static int __maybe_unused advk_pcie_suspend(struct device *dev) +{ + struct advk_pcie *pcie = dev_get_drvdata(dev); + + advk_pcie_disable_phy(pcie); + + clk_disable_unprepare(pcie->clk); + + return 0; +} + +static int __maybe_unused advk_pcie_resume(struct device *dev) +{ + struct advk_pcie *pcie = dev_get_drvdata(dev); + int ret; + + ret = clk_prepare_enable(pcie->clk); + if (ret) + return ret; + + /* + * Empirical delay needed after enabling the clock and before + * accessing any register. + */ + msleep(10); + + ret = advk_pcie_enable_phy(pcie); + if (ret) + return ret; + + advk_pcie_hard_reset(pcie); + + advk_pcie_setup_hw(pcie); + + advk_sw_pci_bridge_init(pcie); + + return 0; +} + +/* + * The PCI core will try to reconfigure the bus quite early in the resume path. + * We must use the _noirq() alternatives to ensure the controller is ready when + * the core uses the ->read()/->write() callbacks. + */ +static const struct dev_pm_ops advk_pcie_dev_pm_ops = { + SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(advk_pcie_suspend, + advk_pcie_resume) +}; + static int advk_pcie_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; @@ -1188,6 +1237,8 @@ static int advk_pcie_probe(struct platform_device *pdev) return ret; } + dev_set_drvdata(dev, pcie); + return 0; } @@ -1200,6 +1251,7 @@ static struct platform_driver advk_pcie_driver = { .driver = { .name = "advk-pcie", .of_match_table = advk_pcie_of_match_table, + .pm = &advk_pcie_dev_pm_ops, /* Driver unloading/unbinding currently not supported */ .suppress_bind_attrs = true, },
Add suspend and resume callbacks. The priority of these are "_noirq()", to workaround early access to the registers done by the PCI core through the ->read()/->write() callbacks at resume time. Signed-off-by: Miquel Raynal <miquel.raynal@bootlin.com> --- drivers/pci/controller/pci-aardvark.c | 52 +++++++++++++++++++++++++++ 1 file changed, 52 insertions(+)