| Message ID | m2eg4ui0nl.fsf@baylibre.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
On 08/09/16 21:42, Kevin Hilman wrote: > Ben Dooks <ben.dooks@codethink.co.uk> writes: > >> On 08/09/16 20:52, Martin Blumenstingl wrote: >>> On Thu, Sep 8, 2016 at 9:35 PM, Kevin Hilman <khilman@baylibre.com> wrote: >>>>> + phy = devm_phy_create(&pdev->dev, NULL, &phy_meson_usb2_ops); >>>>> + if (IS_ERR(phy)) { >>>>> + dev_err(&pdev->dev, "failed to create PHY\n"); >>>>> + return PTR_ERR(phy); >>>>> + } >>>>> + >>>>> + if (usb_reset_refcnt++ == 0) { >>>>> + ret = device_reset(&pdev->dev); >>>>> + if (ret) { >>>>> + dev_err(&phy->dev, "Failed to reset USB PHY\n"); >>>>> + return ret; >>>>> + } >>>>> + } >>>> >>>> The ref count + reset here looks like something that could/should be >>>> handled in a runtime PM callback. >>> Unfortunately that doesn't work (as Jerome found out) because both >>> PHYs are sharing the same reset line. >>> So if the second PHY would call device_reset then it would also reset >>> the first PHY! >>> >>> There's a comment above the declaration of usb_reset_refcnt which >>> tries to explain this: >>> "The PHYs are sharing a common reset line -> we are only allowed to >>> reset once for all PHYs." >>> Maybe I should move this comment to the "if (usb_reset_refcnt++ == 0) >>> {" line to make it easier to see? >>> >> >> pm-runtime has refcounting in it. When one of the nodes turns on, >> the pm-runtime will call your driver to say there is a user when >> this first use turns up. >> >> If all the sub-phys turn off and drop their refcount then the driver >> is called to say there are no more users and you can go to sleep. > > After a chat w/Martin on IRC, It turns out runtime PM wont help here. > > The reason is because there are physically two PHY devices[1]. Those 2 > devices will be treated independely by runtime PM, and have separate > use-counting, which means doing what I proposed would cause a reset to > happen when either device was probed. > > So, I think it's OK as it is. Surely you can do pm_runtime_get/put on the phy's parent platform device and do it that way?
On Thu, Sep 8, 2016 at 10:53 PM, Ben Dooks <ben.dooks@codethink.co.uk> wrote: > On 08/09/16 21:42, Kevin Hilman wrote: >> >> Ben Dooks <ben.dooks@codethink.co.uk> writes: >> >>> On 08/09/16 20:52, Martin Blumenstingl wrote: >>>> >>>> On Thu, Sep 8, 2016 at 9:35 PM, Kevin Hilman <khilman@baylibre.com> >>>> wrote: >>>>>> >>>>>> + phy = devm_phy_create(&pdev->dev, NULL, &phy_meson_usb2_ops); >>>>>> + if (IS_ERR(phy)) { >>>>>> + dev_err(&pdev->dev, "failed to create PHY\n"); >>>>>> + return PTR_ERR(phy); >>>>>> + } >>>>>> + >>>>>> + if (usb_reset_refcnt++ == 0) { >>>>>> + ret = device_reset(&pdev->dev); >>>>>> + if (ret) { >>>>>> + dev_err(&phy->dev, "Failed to reset USB PHY\n"); >>>>>> + return ret; >>>>>> + } >>>>>> + } >>>>> >>>>> >>>>> The ref count + reset here looks like something that could/should be >>>>> handled in a runtime PM callback. >>>> >>>> Unfortunately that doesn't work (as Jerome found out) because both >>>> PHYs are sharing the same reset line. >>>> So if the second PHY would call device_reset then it would also reset >>>> the first PHY! >>>> >>>> There's a comment above the declaration of usb_reset_refcnt which >>>> tries to explain this: >>>> "The PHYs are sharing a common reset line -> we are only allowed to >>>> reset once for all PHYs." >>>> Maybe I should move this comment to the "if (usb_reset_refcnt++ == 0) >>>> {" line to make it easier to see? >>>> >>> >>> pm-runtime has refcounting in it. When one of the nodes turns on, >>> the pm-runtime will call your driver to say there is a user when >>> this first use turns up. >>> >>> If all the sub-phys turn off and drop their refcount then the driver >>> is called to say there are no more users and you can go to sleep. >> >> >> After a chat w/Martin on IRC, It turns out runtime PM wont help here. >> >> The reason is because there are physically two PHY devices[1]. Those 2 >> devices will be treated independely by runtime PM, and have separate >> use-counting, which means doing what I proposed would cause a reset to >> happen when either device was probed. >> >> So, I think it's OK as it is. > > > Surely you can do pm_runtime_get/put on the phy's parent platform > device and do it that way? could you please be more specific with that (do you mean pdev->dev.parent)? so we would use pm_runtime_{get_sync,put} with the parent, while we would still define the runtime_resume in our driver. I'd be happy if that works and we can remove that refcounting hack
Martin Blumenstingl <martin.blumenstingl@googlemail.com> writes: > On Thu, Sep 8, 2016 at 10:53 PM, Ben Dooks <ben.dooks@codethink.co.uk> wrote: >> On 08/09/16 21:42, Kevin Hilman wrote: >>> >>> Ben Dooks <ben.dooks@codethink.co.uk> writes: >>> >>>> On 08/09/16 20:52, Martin Blumenstingl wrote: >>>>> >>>>> On Thu, Sep 8, 2016 at 9:35 PM, Kevin Hilman <khilman@baylibre.com> >>>>> wrote: >>>>>>> >>>>>>> + phy = devm_phy_create(&pdev->dev, NULL, &phy_meson_usb2_ops); >>>>>>> + if (IS_ERR(phy)) { >>>>>>> + dev_err(&pdev->dev, "failed to create PHY\n"); >>>>>>> + return PTR_ERR(phy); >>>>>>> + } >>>>>>> + >>>>>>> + if (usb_reset_refcnt++ == 0) { >>>>>>> + ret = device_reset(&pdev->dev); >>>>>>> + if (ret) { >>>>>>> + dev_err(&phy->dev, "Failed to reset USB PHY\n"); >>>>>>> + return ret; >>>>>>> + } >>>>>>> + } >>>>>> >>>>>> >>>>>> The ref count + reset here looks like something that could/should be >>>>>> handled in a runtime PM callback. >>>>> >>>>> Unfortunately that doesn't work (as Jerome found out) because both >>>>> PHYs are sharing the same reset line. >>>>> So if the second PHY would call device_reset then it would also reset >>>>> the first PHY! >>>>> >>>>> There's a comment above the declaration of usb_reset_refcnt which >>>>> tries to explain this: >>>>> "The PHYs are sharing a common reset line -> we are only allowed to >>>>> reset once for all PHYs." >>>>> Maybe I should move this comment to the "if (usb_reset_refcnt++ == 0) >>>>> {" line to make it easier to see? >>>>> >>>> >>>> pm-runtime has refcounting in it. When one of the nodes turns on, >>>> the pm-runtime will call your driver to say there is a user when >>>> this first use turns up. >>>> >>>> If all the sub-phys turn off and drop their refcount then the driver >>>> is called to say there are no more users and you can go to sleep. >>> >>> >>> After a chat w/Martin on IRC, It turns out runtime PM wont help here. >>> >>> The reason is because there are physically two PHY devices[1]. Those 2 >>> devices will be treated independely by runtime PM, and have separate >>> use-counting, which means doing what I proposed would cause a reset to >>> happen when either device was probed. >>> >>> So, I think it's OK as it is. >> >> >> Surely you can do pm_runtime_get/put on the phy's parent platform >> device and do it that way? > could you please be more specific with that (do you mean pdev->dev.parent)? > so we would use pm_runtime_{get_sync,put} with the parent, while we > would still define the runtime_resume in our driver. You'd also need to do get/put on the children, but yes, that's what Ben is suggesting. However, the problem with all of the solutions proposed (runtime PM ones included) is that we're forcing a board-specific design issue (2 devices sharing a reset line) into a driver that should not have any board-specific assumptions in it. For example, if this driver is used on another platform where different PHYs have different reset lines, then one of them (the unlucky one who is not probed first) will never get reset. So any form of per-device ref-counting is not a portable solution. I'm not sure yet how the reset framework is supposed to handle shared reset lines, but that needs some investigation. I quick glance and it seems that reset controllers can have shared lines, so that should be investigated. Kevin
On Fri, Sep 9, 2016 at 5:33 PM, Kevin Hilman <khilman@baylibre.com> wrote: > However, the problem with all of the solutions proposed (runtime PM ones > included) is that we're forcing a board-specific design issue (2 devices > sharing a reset line) into a driver that should not have any > board-specific assumptions in it. > > For example, if this driver is used on another platform where different > PHYs have different reset lines, then one of them (the unlucky one who > is not probed first) will never get reset. So any form of per-device > ref-counting is not a portable solution. maybe we should also consider Ben's solution: he played with the USB PHY on his Meson8b board. His approach was to have only one USB PHY driver instance which exposes two PHYs. The downside of this: the driver would have to know the offset of the PHYs (0x0 for the first PHY, 0x20 for the second), but we could handle the reset using runtime PM without any hacks. I checked the USB PHY reference driver: it seems that there will be a new USB PHY with the GXL/GXM SoCs. So maybe we could live with the assumption that the PHYs are at consecutive addresses. > I'm not sure yet how the reset framework is supposed to handle shared > reset lines, but that needs some investigation. I quick glance and it > seems that reset controllers can have shared lines, so that should be > investigated. unfortunately shared resets are not allowed to use reset_control_reset, see [0] [0] http://lxr.free-electrons.com/source/drivers/reset/core.c#L102
Martin Blumenstingl <martin.blumenstingl@googlemail.com> writes: > On Fri, Sep 9, 2016 at 5:33 PM, Kevin Hilman <khilman@baylibre.com> wrote: >> However, the problem with all of the solutions proposed (runtime PM ones >> included) is that we're forcing a board-specific design issue (2 devices >> sharing a reset line) into a driver that should not have any >> board-specific assumptions in it. >> >> For example, if this driver is used on another platform where different >> PHYs have different reset lines, then one of them (the unlucky one who >> is not probed first) will never get reset. So any form of per-device >> ref-counting is not a portable solution. > > maybe we should also consider Ben's solution: he played with the USB > PHY on his Meson8b board. His approach was to have only one USB PHY > driver instance which exposes two PHYs. > The downside of this: the driver would have to know the offset of the > PHYs (0x0 for the first PHY, 0x20 for the second), but we could handle > the reset using runtime PM without any hacks. > I checked the USB PHY reference driver: it seems that there will be a > new USB PHY with the GXL/GXM SoCs. > So maybe we could live with the assumption that the PHYs are at > consecutive addresses. But isn't that also forcing us to make board-specific assumptions inside the driver. Kevin
On 09/09/16 17:14, Martin Blumenstingl wrote: > On Fri, Sep 9, 2016 at 5:33 PM, Kevin Hilman <khilman@baylibre.com> wrote: >> However, the problem with all of the solutions proposed (runtime PM ones >> included) is that we're forcing a board-specific design issue (2 devices >> sharing a reset line) into a driver that should not have any >> board-specific assumptions in it. >> >> For example, if this driver is used on another platform where different >> PHYs have different reset lines, then one of them (the unlucky one who >> is not probed first) will never get reset. So any form of per-device >> ref-counting is not a portable solution. > maybe we should also consider Ben's solution: he played with the USB > PHY on his Meson8b board. His approach was to have only one USB PHY > driver instance which exposes two PHYs. > The downside of this: the driver would have to know the offset of the > PHYs (0x0 for the first PHY, 0x20 for the second), but we could handle > the reset using runtime PM without any hacks. > > I checked the USB PHY reference driver: it seems that there will be a > new USB PHY with the GXL/GXM SoCs. > So maybe we could live with the assumption that the PHYs are at > consecutive addresses. > >> I'm not sure yet how the reset framework is supposed to handle shared >> reset lines, but that needs some investigation. I quick glance and it >> seems that reset controllers can have shared lines, so that should be >> investigated. > unfortunately shared resets are not allowed to use reset_control_reset, see [0] > > > [0] http://lxr.free-electrons.com/source/drivers/reset/core.c#L102 If we didn't have the shared reset, we'd have one of node per phy and not have to have two sub-nodes... I don't think any other bits of the PHY framework are shared.
On Fri, Sep 9, 2016 at 5:33 PM, Kevin Hilman <khilman@baylibre.com> wrote: > Martin Blumenstingl <martin.blumenstingl@googlemail.com> writes: > >> On Thu, Sep 8, 2016 at 10:53 PM, Ben Dooks <ben.dooks@codethink.co.uk> wrote: >>> On 08/09/16 21:42, Kevin Hilman wrote: >>>> >>>> Ben Dooks <ben.dooks@codethink.co.uk> writes: >>>> >>>>> On 08/09/16 20:52, Martin Blumenstingl wrote: >>>>>> >>>>>> On Thu, Sep 8, 2016 at 9:35 PM, Kevin Hilman <khilman@baylibre.com> >>>>>> wrote: >>>>>>>> >>>>>>>> + phy = devm_phy_create(&pdev->dev, NULL, &phy_meson_usb2_ops); >>>>>>>> + if (IS_ERR(phy)) { >>>>>>>> + dev_err(&pdev->dev, "failed to create PHY\n"); >>>>>>>> + return PTR_ERR(phy); >>>>>>>> + } >>>>>>>> + >>>>>>>> + if (usb_reset_refcnt++ == 0) { >>>>>>>> + ret = device_reset(&pdev->dev); >>>>>>>> + if (ret) { >>>>>>>> + dev_err(&phy->dev, "Failed to reset USB PHY\n"); >>>>>>>> + return ret; >>>>>>>> + } >>>>>>>> + } >>>>>>> >>>>>>> >>>>>>> The ref count + reset here looks like something that could/should be >>>>>>> handled in a runtime PM callback. >>>>>> >>>>>> Unfortunately that doesn't work (as Jerome found out) because both >>>>>> PHYs are sharing the same reset line. >>>>>> So if the second PHY would call device_reset then it would also reset >>>>>> the first PHY! >>>>>> >>>>>> There's a comment above the declaration of usb_reset_refcnt which >>>>>> tries to explain this: >>>>>> "The PHYs are sharing a common reset line -> we are only allowed to >>>>>> reset once for all PHYs." >>>>>> Maybe I should move this comment to the "if (usb_reset_refcnt++ == 0) >>>>>> {" line to make it easier to see? >>>>>> >>>>> >>>>> pm-runtime has refcounting in it. When one of the nodes turns on, >>>>> the pm-runtime will call your driver to say there is a user when >>>>> this first use turns up. >>>>> >>>>> If all the sub-phys turn off and drop their refcount then the driver >>>>> is called to say there are no more users and you can go to sleep. >>>> >>>> >>>> After a chat w/Martin on IRC, It turns out runtime PM wont help here. >>>> >>>> The reason is because there are physically two PHY devices[1]. Those 2 >>>> devices will be treated independely by runtime PM, and have separate >>>> use-counting, which means doing what I proposed would cause a reset to >>>> happen when either device was probed. >>>> >>>> So, I think it's OK as it is. >>> >>> >>> Surely you can do pm_runtime_get/put on the phy's parent platform >>> device and do it that way? >> could you please be more specific with that (do you mean pdev->dev.parent)? >> so we would use pm_runtime_{get_sync,put} with the parent, while we >> would still define the runtime_resume in our driver. > > You'd also need to do get/put on the children, but yes, that's what Ben > is suggesting. > > However, the problem with all of the solutions proposed (runtime PM ones > included) is that we're forcing a board-specific design issue (2 devices > sharing a reset line) into a driver that should not have any > board-specific assumptions in it. > > For example, if this driver is used on another platform where different > PHYs have different reset lines, then one of them (the unlucky one who > is not probed first) will never get reset. So any form of per-device > ref-counting is not a portable solution. indeed, so in simple words we would need something like reset_control_do_once(rstc, RESET/ASSERT/DEASSERT) which would remember internally if any action has already been executed: if not it does a _reset, _assert or _deassert and otherwise it does nothing. > I'm not sure yet how the reset framework is supposed to handle shared > reset lines, but that needs some investigation. I quick glance and it > seems that reset controllers can have shared lines, so that should be > investigated. I added Philipp and Hans to this thread - maybe they can comment on this. To sum it up, our problem is: - there are two separate USB PHYs on Meson GXBB - both are sharing the same reset line (provided by the reset-meson driver) - during initialization of the PHYs we must only call reset_control_reset(rstc) once (if we do it for the first *and* second PHY then the first PHY gets confused once the second PHY uses the reset because the first PHY's state is reset as well) Regards, Martin
On Fri, Sep 9, 2016 at 7:21 PM, Ben Dooks <ben.dooks@codethink.co.uk> wrote: > On 09/09/16 17:14, Martin Blumenstingl wrote: >> >> On Fri, Sep 9, 2016 at 5:33 PM, Kevin Hilman <khilman@baylibre.com> wrote: >>> >>> However, the problem with all of the solutions proposed (runtime PM ones >>> included) is that we're forcing a board-specific design issue (2 devices >>> sharing a reset line) into a driver that should not have any >>> board-specific assumptions in it. >>> >>> For example, if this driver is used on another platform where different >>> PHYs have different reset lines, then one of them (the unlucky one who >>> is not probed first) will never get reset. So any form of per-device >>> ref-counting is not a portable solution. >> >> maybe we should also consider Ben's solution: he played with the USB >> PHY on his Meson8b board. His approach was to have only one USB PHY >> driver instance which exposes two PHYs. >> The downside of this: the driver would have to know the offset of the >> PHYs (0x0 for the first PHY, 0x20 for the second), but we could handle >> the reset using runtime PM without any hacks. >> >> I checked the USB PHY reference driver: it seems that there will be a >> new USB PHY with the GXL/GXM SoCs. >> So maybe we could live with the assumption that the PHYs are at >> consecutive addresses. >> >>> I'm not sure yet how the reset framework is supposed to handle shared >>> reset lines, but that needs some investigation. I quick glance and it >>> seems that reset controllers can have shared lines, so that should be >>> investigated. >> >> unfortunately shared resets are not allowed to use reset_control_reset, >> see [0] >> >> >> [0] http://lxr.free-electrons.com/source/drivers/reset/core.c#L102 > > > If we didn't have the shared reset, we'd have one of node per phy > and not have to have two sub-nodes... I don't think any other bits > of the PHY framework are shared. okay, sounds reasonable - so we should try to get this scenario supported through by the reset framework -> see my other mail.
On Fri, Sep 9, 2016 at 10:36 PM, Martin Blumenstingl <martin.blumenstingl@googlemail.com> wrote: > On Fri, Sep 9, 2016 at 5:33 PM, Kevin Hilman <khilman@baylibre.com> wrote: >> Martin Blumenstingl <martin.blumenstingl@googlemail.com> writes: >> >>> On Thu, Sep 8, 2016 at 10:53 PM, Ben Dooks <ben.dooks@codethink.co.uk> wrote: >>>> On 08/09/16 21:42, Kevin Hilman wrote: >>>>> >>>>> Ben Dooks <ben.dooks@codethink.co.uk> writes: >>>>> >>>>>> On 08/09/16 20:52, Martin Blumenstingl wrote: >>>>>>> >>>>>>> On Thu, Sep 8, 2016 at 9:35 PM, Kevin Hilman <khilman@baylibre.com> >>>>>>> wrote: >>>>>>>>> >>>>>>>>> + phy = devm_phy_create(&pdev->dev, NULL, &phy_meson_usb2_ops); >>>>>>>>> + if (IS_ERR(phy)) { >>>>>>>>> + dev_err(&pdev->dev, "failed to create PHY\n"); >>>>>>>>> + return PTR_ERR(phy); >>>>>>>>> + } >>>>>>>>> + >>>>>>>>> + if (usb_reset_refcnt++ == 0) { >>>>>>>>> + ret = device_reset(&pdev->dev); >>>>>>>>> + if (ret) { >>>>>>>>> + dev_err(&phy->dev, "Failed to reset USB PHY\n"); >>>>>>>>> + return ret; >>>>>>>>> + } >>>>>>>>> + } >>>>>>>> >>>>>>>> >>>>>>>> The ref count + reset here looks like something that could/should be >>>>>>>> handled in a runtime PM callback. >>>>>>> >>>>>>> Unfortunately that doesn't work (as Jerome found out) because both >>>>>>> PHYs are sharing the same reset line. >>>>>>> So if the second PHY would call device_reset then it would also reset >>>>>>> the first PHY! >>>>>>> >>>>>>> There's a comment above the declaration of usb_reset_refcnt which >>>>>>> tries to explain this: >>>>>>> "The PHYs are sharing a common reset line -> we are only allowed to >>>>>>> reset once for all PHYs." >>>>>>> Maybe I should move this comment to the "if (usb_reset_refcnt++ == 0) >>>>>>> {" line to make it easier to see? >>>>>>> >>>>>> >>>>>> pm-runtime has refcounting in it. When one of the nodes turns on, >>>>>> the pm-runtime will call your driver to say there is a user when >>>>>> this first use turns up. >>>>>> >>>>>> If all the sub-phys turn off and drop their refcount then the driver >>>>>> is called to say there are no more users and you can go to sleep. >>>>> >>>>> >>>>> After a chat w/Martin on IRC, It turns out runtime PM wont help here. >>>>> >>>>> The reason is because there are physically two PHY devices[1]. Those 2 >>>>> devices will be treated independely by runtime PM, and have separate >>>>> use-counting, which means doing what I proposed would cause a reset to >>>>> happen when either device was probed. >>>>> >>>>> So, I think it's OK as it is. >>>> >>>> >>>> Surely you can do pm_runtime_get/put on the phy's parent platform >>>> device and do it that way? >>> could you please be more specific with that (do you mean pdev->dev.parent)? >>> so we would use pm_runtime_{get_sync,put} with the parent, while we >>> would still define the runtime_resume in our driver. >> >> You'd also need to do get/put on the children, but yes, that's what Ben >> is suggesting. >> >> However, the problem with all of the solutions proposed (runtime PM ones >> included) is that we're forcing a board-specific design issue (2 devices >> sharing a reset line) into a driver that should not have any >> board-specific assumptions in it. >> >> For example, if this driver is used on another platform where different >> PHYs have different reset lines, then one of them (the unlucky one who >> is not probed first) will never get reset. So any form of per-device >> ref-counting is not a portable solution. > indeed, so in simple words we would need something like > reset_control_do_once(rstc, RESET/ASSERT/DEASSERT) which would > remember internally if any action has already been executed: if not it > does a _reset, _assert or _deassert and otherwise it does nothing. for now I've implemented something less hacky: I made the reset optional and only specified it for phy0. During Jerome's tests the reset was not needed, while on my board it's required to bring both PHYs up. Additionally the USB PHY reference driver does not have any reset logic for newer SoCs (GXL), so making the reset optional doesn't sound that bad to me.
Martin Blumenstingl <martin.blumenstingl@googlemail.com> writes: > On Fri, Sep 9, 2016 at 10:36 PM, Martin Blumenstingl > <martin.blumenstingl@googlemail.com> wrote: >> On Fri, Sep 9, 2016 at 5:33 PM, Kevin Hilman <khilman@baylibre.com> wrote: >>> Martin Blumenstingl <martin.blumenstingl@googlemail.com> writes: >>> >>>> On Thu, Sep 8, 2016 at 10:53 PM, Ben Dooks <ben.dooks@codethink.co.uk> wrote: >>>>> On 08/09/16 21:42, Kevin Hilman wrote: >>>>>> >>>>>> Ben Dooks <ben.dooks@codethink.co.uk> writes: >>>>>> >>>>>>> On 08/09/16 20:52, Martin Blumenstingl wrote: >>>>>>>> >>>>>>>> On Thu, Sep 8, 2016 at 9:35 PM, Kevin Hilman <khilman@baylibre.com> >>>>>>>> wrote: >>>>>>>>>> >>>>>>>>>> + phy = devm_phy_create(&pdev->dev, NULL, &phy_meson_usb2_ops); >>>>>>>>>> + if (IS_ERR(phy)) { >>>>>>>>>> + dev_err(&pdev->dev, "failed to create PHY\n"); >>>>>>>>>> + return PTR_ERR(phy); >>>>>>>>>> + } >>>>>>>>>> + >>>>>>>>>> + if (usb_reset_refcnt++ == 0) { >>>>>>>>>> + ret = device_reset(&pdev->dev); >>>>>>>>>> + if (ret) { >>>>>>>>>> + dev_err(&phy->dev, "Failed to reset USB PHY\n"); >>>>>>>>>> + return ret; >>>>>>>>>> + } >>>>>>>>>> + } >>>>>>>>> >>>>>>>>> >>>>>>>>> The ref count + reset here looks like something that could/should be >>>>>>>>> handled in a runtime PM callback. >>>>>>>> >>>>>>>> Unfortunately that doesn't work (as Jerome found out) because both >>>>>>>> PHYs are sharing the same reset line. >>>>>>>> So if the second PHY would call device_reset then it would also reset >>>>>>>> the first PHY! >>>>>>>> >>>>>>>> There's a comment above the declaration of usb_reset_refcnt which >>>>>>>> tries to explain this: >>>>>>>> "The PHYs are sharing a common reset line -> we are only allowed to >>>>>>>> reset once for all PHYs." >>>>>>>> Maybe I should move this comment to the "if (usb_reset_refcnt++ == 0) >>>>>>>> {" line to make it easier to see? >>>>>>>> >>>>>>> >>>>>>> pm-runtime has refcounting in it. When one of the nodes turns on, >>>>>>> the pm-runtime will call your driver to say there is a user when >>>>>>> this first use turns up. >>>>>>> >>>>>>> If all the sub-phys turn off and drop their refcount then the driver >>>>>>> is called to say there are no more users and you can go to sleep. >>>>>> >>>>>> >>>>>> After a chat w/Martin on IRC, It turns out runtime PM wont help here. >>>>>> >>>>>> The reason is because there are physically two PHY devices[1]. Those 2 >>>>>> devices will be treated independely by runtime PM, and have separate >>>>>> use-counting, which means doing what I proposed would cause a reset to >>>>>> happen when either device was probed. >>>>>> >>>>>> So, I think it's OK as it is. >>>>> >>>>> >>>>> Surely you can do pm_runtime_get/put on the phy's parent platform >>>>> device and do it that way? >>>> could you please be more specific with that (do you mean pdev->dev.parent)? >>>> so we would use pm_runtime_{get_sync,put} with the parent, while we >>>> would still define the runtime_resume in our driver. >>> >>> You'd also need to do get/put on the children, but yes, that's what Ben >>> is suggesting. >>> >>> However, the problem with all of the solutions proposed (runtime PM ones >>> included) is that we're forcing a board-specific design issue (2 devices >>> sharing a reset line) into a driver that should not have any >>> board-specific assumptions in it. >>> >>> For example, if this driver is used on another platform where different >>> PHYs have different reset lines, then one of them (the unlucky one who >>> is not probed first) will never get reset. So any form of per-device >>> ref-counting is not a portable solution. >> indeed, so in simple words we would need something like >> reset_control_do_once(rstc, RESET/ASSERT/DEASSERT) which would >> remember internally if any action has already been executed: if not it >> does a _reset, _assert or _deassert and otherwise it does nothing. > for now I've implemented something less hacky: I made the reset > optional and only specified it for phy0. That's slightly better, but could misbehave if devices are probed/loaded in different order? But, that shouldn't be a blocker for the driver. > During Jerome's tests the reset was not needed, while on my board it's > required to bring both PHYs up. > Additionally the USB PHY reference driver does not have any reset > logic for newer SoCs (GXL), so making the reset optional doesn't sound > that bad to me. Agreed. Kevin
Hi Martin, Am Freitag, den 09.09.2016, 22:36 +0200 schrieb Martin Blumenstingl: > On Fri, Sep 9, 2016 at 5:33 PM, Kevin Hilman <khilman@baylibre.com> wrote: > > Martin Blumenstingl <martin.blumenstingl@googlemail.com> writes: > > > >> On Thu, Sep 8, 2016 at 10:53 PM, Ben Dooks <ben.dooks@codethink.co.uk> wrote: > >>> On 08/09/16 21:42, Kevin Hilman wrote: > >>>> > >>>> Ben Dooks <ben.dooks@codethink.co.uk> writes: > >>>> > >>>>> On 08/09/16 20:52, Martin Blumenstingl wrote: > >>>>>> > >>>>>> On Thu, Sep 8, 2016 at 9:35 PM, Kevin Hilman <khilman@baylibre.com> > >>>>>> wrote: > >>>>>>>> > >>>>>>>> + phy = devm_phy_create(&pdev->dev, NULL, &phy_meson_usb2_ops); > >>>>>>>> + if (IS_ERR(phy)) { > >>>>>>>> + dev_err(&pdev->dev, "failed to create PHY\n"); > >>>>>>>> + return PTR_ERR(phy); > >>>>>>>> + } > >>>>>>>> + > >>>>>>>> + if (usb_reset_refcnt++ == 0) { > >>>>>>>> + ret = device_reset(&pdev->dev); > >>>>>>>> + if (ret) { > >>>>>>>> + dev_err(&phy->dev, "Failed to reset USB PHY\n"); > >>>>>>>> + return ret; > >>>>>>>> + } > >>>>>>>> + } > >>>>>>> > >>>>>>> > >>>>>>> The ref count + reset here looks like something that could/should be > >>>>>>> handled in a runtime PM callback. > >>>>>> > >>>>>> Unfortunately that doesn't work (as Jerome found out) because both > >>>>>> PHYs are sharing the same reset line. > >>>>>> So if the second PHY would call device_reset then it would also reset > >>>>>> the first PHY! > >>>>>> > >>>>>> There's a comment above the declaration of usb_reset_refcnt which > >>>>>> tries to explain this: > >>>>>> "The PHYs are sharing a common reset line -> we are only allowed to > >>>>>> reset once for all PHYs." > >>>>>> Maybe I should move this comment to the "if (usb_reset_refcnt++ == 0) > >>>>>> {" line to make it easier to see? > >>>>>> > >>>>> > >>>>> pm-runtime has refcounting in it. When one of the nodes turns on, > >>>>> the pm-runtime will call your driver to say there is a user when > >>>>> this first use turns up. > >>>>> > >>>>> If all the sub-phys turn off and drop their refcount then the driver > >>>>> is called to say there are no more users and you can go to sleep. > >>>> > >>>> > >>>> After a chat w/Martin on IRC, It turns out runtime PM wont help here. > >>>> > >>>> The reason is because there are physically two PHY devices[1]. Those 2 > >>>> devices will be treated independely by runtime PM, and have separate > >>>> use-counting, which means doing what I proposed would cause a reset to > >>>> happen when either device was probed. > >>>> > >>>> So, I think it's OK as it is. > >>> > >>> > >>> Surely you can do pm_runtime_get/put on the phy's parent platform > >>> device and do it that way? > >> could you please be more specific with that (do you mean pdev->dev.parent)? > >> so we would use pm_runtime_{get_sync,put} with the parent, while we > >> would still define the runtime_resume in our driver. > > > > You'd also need to do get/put on the children, but yes, that's what Ben > > is suggesting. > > > > However, the problem with all of the solutions proposed (runtime PM ones > > included) is that we're forcing a board-specific design issue (2 devices > > sharing a reset line) into a driver that should not have any > > board-specific assumptions in it. > > > > For example, if this driver is used on another platform where different > > PHYs have different reset lines, then one of them (the unlucky one who > > is not probed first) will never get reset. So any form of per-device > > ref-counting is not a portable solution. > indeed, so in simple words we would need something like > reset_control_do_once(rstc, RESET/ASSERT/DEASSERT) which would > remember internally if any action has already been executed: if not it > does a _reset, _assert or _deassert and otherwise it does nothing. > > > I'm not sure yet how the reset framework is supposed to handle shared > > reset lines, but that needs some investigation. I quick glance and it > > seems that reset controllers can have shared lines, so that should be > > investigated. > I added Philipp and Hans to this thread - maybe they can comment on this. > To sum it up, our problem is: > - there are two separate USB PHYs on Meson GXBB > - both are sharing the same reset line (provided by the reset-meson driver) > - during initialization of the PHYs we must only call > reset_control_reset(rstc) once (if we do it for the first *and* second > PHY then the first PHY gets confused once the second PHY uses the > reset because the first PHY's state is reset as well) If you have an initially asserted reset line and you can enable the first module by deasserting the reset via reset_control_deassert (and reset_control_assert to signal when the module may be disabled again after use), shared resets are for you. If you need a reset pulse or have no direct control over the reset line, (device_reset), the reset framework currently has no solution for this. The ugly thing about reset_control_once would be that it can't re-reset modules when unloading and reloading driver modules. A real solution for shared reset lines with reset pulses would have to be some kind of reset request framework where if one module requests a reset, the other module sharing the reset could be notified, and then either veto the reset or, if possible, cease operations, store its state, and prepare to be reset, too, and afterwards restore state. I'd prefer not to think about this too much unless absolutely necessary. regards Philipp
Hi Philipp, On Tue, Sep 13, 2016 at 5:28 PM, Philipp Zabel <p.zabel@pengutronix.de> wrote: > Hi Martin, > > Am Freitag, den 09.09.2016, 22:36 +0200 schrieb Martin Blumenstingl: >> On Fri, Sep 9, 2016 at 5:33 PM, Kevin Hilman <khilman@baylibre.com> wrote: >> > Martin Blumenstingl <martin.blumenstingl@googlemail.com> writes: >> > >> >> On Thu, Sep 8, 2016 at 10:53 PM, Ben Dooks <ben.dooks@codethink.co.uk> wrote: >> >>> On 08/09/16 21:42, Kevin Hilman wrote: >> >>>> >> >>>> Ben Dooks <ben.dooks@codethink.co.uk> writes: >> >>>> >> >>>>> On 08/09/16 20:52, Martin Blumenstingl wrote: >> >>>>>> >> >>>>>> On Thu, Sep 8, 2016 at 9:35 PM, Kevin Hilman <khilman@baylibre.com> >> >>>>>> wrote: >> >>>>>>>> >> >>>>>>>> + phy = devm_phy_create(&pdev->dev, NULL, &phy_meson_usb2_ops); >> >>>>>>>> + if (IS_ERR(phy)) { >> >>>>>>>> + dev_err(&pdev->dev, "failed to create PHY\n"); >> >>>>>>>> + return PTR_ERR(phy); >> >>>>>>>> + } >> >>>>>>>> + >> >>>>>>>> + if (usb_reset_refcnt++ == 0) { >> >>>>>>>> + ret = device_reset(&pdev->dev); >> >>>>>>>> + if (ret) { >> >>>>>>>> + dev_err(&phy->dev, "Failed to reset USB PHY\n"); >> >>>>>>>> + return ret; >> >>>>>>>> + } >> >>>>>>>> + } >> >>>>>>> >> >>>>>>> >> >>>>>>> The ref count + reset here looks like something that could/should be >> >>>>>>> handled in a runtime PM callback. >> >>>>>> >> >>>>>> Unfortunately that doesn't work (as Jerome found out) because both >> >>>>>> PHYs are sharing the same reset line. >> >>>>>> So if the second PHY would call device_reset then it would also reset >> >>>>>> the first PHY! >> >>>>>> >> >>>>>> There's a comment above the declaration of usb_reset_refcnt which >> >>>>>> tries to explain this: >> >>>>>> "The PHYs are sharing a common reset line -> we are only allowed to >> >>>>>> reset once for all PHYs." >> >>>>>> Maybe I should move this comment to the "if (usb_reset_refcnt++ == 0) >> >>>>>> {" line to make it easier to see? >> >>>>>> >> >>>>> >> >>>>> pm-runtime has refcounting in it. When one of the nodes turns on, >> >>>>> the pm-runtime will call your driver to say there is a user when >> >>>>> this first use turns up. >> >>>>> >> >>>>> If all the sub-phys turn off and drop their refcount then the driver >> >>>>> is called to say there are no more users and you can go to sleep. >> >>>> >> >>>> >> >>>> After a chat w/Martin on IRC, It turns out runtime PM wont help here. >> >>>> >> >>>> The reason is because there are physically two PHY devices[1]. Those 2 >> >>>> devices will be treated independely by runtime PM, and have separate >> >>>> use-counting, which means doing what I proposed would cause a reset to >> >>>> happen when either device was probed. >> >>>> >> >>>> So, I think it's OK as it is. >> >>> >> >>> >> >>> Surely you can do pm_runtime_get/put on the phy's parent platform >> >>> device and do it that way? >> >> could you please be more specific with that (do you mean pdev->dev.parent)? >> >> so we would use pm_runtime_{get_sync,put} with the parent, while we >> >> would still define the runtime_resume in our driver. >> > >> > You'd also need to do get/put on the children, but yes, that's what Ben >> > is suggesting. >> > >> > However, the problem with all of the solutions proposed (runtime PM ones >> > included) is that we're forcing a board-specific design issue (2 devices >> > sharing a reset line) into a driver that should not have any >> > board-specific assumptions in it. >> > >> > For example, if this driver is used on another platform where different >> > PHYs have different reset lines, then one of them (the unlucky one who >> > is not probed first) will never get reset. So any form of per-device >> > ref-counting is not a portable solution. >> indeed, so in simple words we would need something like >> reset_control_do_once(rstc, RESET/ASSERT/DEASSERT) which would >> remember internally if any action has already been executed: if not it >> does a _reset, _assert or _deassert and otherwise it does nothing. >> >> > I'm not sure yet how the reset framework is supposed to handle shared >> > reset lines, but that needs some investigation. I quick glance and it >> > seems that reset controllers can have shared lines, so that should be >> > investigated. >> I added Philipp and Hans to this thread - maybe they can comment on this. >> To sum it up, our problem is: >> - there are two separate USB PHYs on Meson GXBB >> - both are sharing the same reset line (provided by the reset-meson driver) >> - during initialization of the PHYs we must only call >> reset_control_reset(rstc) once (if we do it for the first *and* second >> PHY then the first PHY gets confused once the second PHY uses the >> reset because the first PHY's state is reset as well) > > If you have an initially asserted reset line and you can enable the > first module by deasserting the reset via reset_control_deassert (and > reset_control_assert to signal when the module may be disabled again > after use), shared resets are for you. > > If you need a reset pulse or have no direct control over the reset line, > (device_reset), the reset framework currently has no solution for this. > The ugly thing about reset_control_once would be that it can't re-reset > modules when unloading and reloading driver modules. The corresponding reset driver in question is reset-meson, which only implements reset (assert/deassert are not implemented). However, I don't know if this is due to hardware design. I think the hardware implements the latter, but maybe Neil can give more information here (I currently don't have access to my board so I cannot test how the hardware actually behaves). > A real solution for shared reset lines with reset pulses would have to > be some kind of reset request framework where if one module requests a > reset, the other module sharing the reset could be notified, and then > either veto the reset or, if possible, cease operations, store its > state, and prepare to be reset, too, and afterwards restore state. I'd > prefer not to think about this too much unless absolutely necessary. I'm not sure if this would work in our case: one PHY instance would have to know if the other has already triggered the reset or not. Regards, Martin
Martin Blumenstingl <martin.blumenstingl@googlemail.com> writes: > On Tue, Sep 13, 2016 at 5:28 PM, Philipp Zabel <p.zabel@pengutronix.de> wrote: [...] >>> I added Philipp and Hans to this thread - maybe they can comment on this. >>> To sum it up, our problem is: >>> - there are two separate USB PHYs on Meson GXBB >>> - both are sharing the same reset line (provided by the reset-meson driver) >>> - during initialization of the PHYs we must only call >>> reset_control_reset(rstc) once (if we do it for the first *and* second >>> PHY then the first PHY gets confused once the second PHY uses the >>> reset because the first PHY's state is reset as well) >> >> If you have an initially asserted reset line and you can enable the >> first module by deasserting the reset via reset_control_deassert (and >> reset_control_assert to signal when the module may be disabled again >> after use), shared resets are for you. >> >> If you need a reset pulse or have no direct control over the reset line, >> (device_reset), the reset framework currently has no solution for this. >> The ugly thing about reset_control_once would be that it can't re-reset >> modules when unloading and reloading driver modules. > > The corresponding reset driver in question is reset-meson, which only > implements reset (assert/deassert are not implemented). However, I > don't know if this is due to hardware design. > I think the hardware implements the latter, but maybe Neil can give > more information here (I currently don't have access to my board so I > cannot test how the hardware actually behaves). It's implemented that way because the hardware only supports a reset pulse. Kevin
Am Dienstag, den 13.09.2016, 17:59 -0700 schrieb Kevin Hilman: > Martin Blumenstingl <martin.blumenstingl@googlemail.com> writes: > > > On Tue, Sep 13, 2016 at 5:28 PM, Philipp Zabel <p.zabel@pengutronix.de> wrote: > > [...] > > >>> I added Philipp and Hans to this thread - maybe they can comment on this. > >>> To sum it up, our problem is: > >>> - there are two separate USB PHYs on Meson GXBB > >>> - both are sharing the same reset line (provided by the reset-meson driver) > >>> - during initialization of the PHYs we must only call > >>> reset_control_reset(rstc) once (if we do it for the first *and* second > >>> PHY then the first PHY gets confused once the second PHY uses the > >>> reset because the first PHY's state is reset as well) > >> > >> If you have an initially asserted reset line and you can enable the > >> first module by deasserting the reset via reset_control_deassert (and > >> reset_control_assert to signal when the module may be disabled again > >> after use), shared resets are for you. > >> > >> If you need a reset pulse or have no direct control over the reset line, > >> (device_reset), the reset framework currently has no solution for this. > >> The ugly thing about reset_control_once would be that it can't re-reset > >> modules when unloading and reloading driver modules. > > > > The corresponding reset driver in question is reset-meson, which only > > implements reset (assert/deassert are not implemented). However, I > > don't know if this is due to hardware design. > > I think the hardware implements the latter, but maybe Neil can give > > more information here (I currently don't have access to my board so I > > cannot test how the hardware actually behaves). > > It's implemented that way because the hardware only supports a reset > pulse. Would it be possible to bring down both PHYs drivers, pull the reset line once, and then bring the drivers back up again on this hardware? regards Philipp
Am Dienstag, den 13.09.2016, 20:38 +0200 schrieb Martin Blumenstingl: > Hi Philipp, > > On Tue, Sep 13, 2016 at 5:28 PM, Philipp Zabel <p.zabel@pengutronix.de> wrote: > > Hi Martin, > > > > Am Freitag, den 09.09.2016, 22:36 +0200 schrieb Martin Blumenstingl: > >> On Fri, Sep 9, 2016 at 5:33 PM, Kevin Hilman <khilman@baylibre.com> wrote: > >> > Martin Blumenstingl <martin.blumenstingl@googlemail.com> writes: > >> > > >> >> On Thu, Sep 8, 2016 at 10:53 PM, Ben Dooks <ben.dooks@codethink.co.uk> wrote: > >> >>> On 08/09/16 21:42, Kevin Hilman wrote: > >> >>>> > >> >>>> Ben Dooks <ben.dooks@codethink.co.uk> writes: > >> >>>> > >> >>>>> On 08/09/16 20:52, Martin Blumenstingl wrote: > >> >>>>>> > >> >>>>>> On Thu, Sep 8, 2016 at 9:35 PM, Kevin Hilman <khilman@baylibre.com> > >> >>>>>> wrote: > >> >>>>>>>> > >> >>>>>>>> + phy = devm_phy_create(&pdev->dev, NULL, &phy_meson_usb2_ops); > >> >>>>>>>> + if (IS_ERR(phy)) { > >> >>>>>>>> + dev_err(&pdev->dev, "failed to create PHY\n"); > >> >>>>>>>> + return PTR_ERR(phy); > >> >>>>>>>> + } > >> >>>>>>>> + > >> >>>>>>>> + if (usb_reset_refcnt++ == 0) { > >> >>>>>>>> + ret = device_reset(&pdev->dev); > >> >>>>>>>> + if (ret) { > >> >>>>>>>> + dev_err(&phy->dev, "Failed to reset USB PHY\n"); > >> >>>>>>>> + return ret; > >> >>>>>>>> + } > >> >>>>>>>> + } > >> >>>>>>> > >> >>>>>>> > >> >>>>>>> The ref count + reset here looks like something that could/should be > >> >>>>>>> handled in a runtime PM callback. > >> >>>>>> > >> >>>>>> Unfortunately that doesn't work (as Jerome found out) because both > >> >>>>>> PHYs are sharing the same reset line. > >> >>>>>> So if the second PHY would call device_reset then it would also reset > >> >>>>>> the first PHY! > >> >>>>>> > >> >>>>>> There's a comment above the declaration of usb_reset_refcnt which > >> >>>>>> tries to explain this: > >> >>>>>> "The PHYs are sharing a common reset line -> we are only allowed to > >> >>>>>> reset once for all PHYs." > >> >>>>>> Maybe I should move this comment to the "if (usb_reset_refcnt++ == 0) > >> >>>>>> {" line to make it easier to see? > >> >>>>>> > >> >>>>> > >> >>>>> pm-runtime has refcounting in it. When one of the nodes turns on, > >> >>>>> the pm-runtime will call your driver to say there is a user when > >> >>>>> this first use turns up. > >> >>>>> > >> >>>>> If all the sub-phys turn off and drop their refcount then the driver > >> >>>>> is called to say there are no more users and you can go to sleep. > >> >>>> > >> >>>> > >> >>>> After a chat w/Martin on IRC, It turns out runtime PM wont help here. > >> >>>> > >> >>>> The reason is because there are physically two PHY devices[1]. Those 2 > >> >>>> devices will be treated independely by runtime PM, and have separate > >> >>>> use-counting, which means doing what I proposed would cause a reset to > >> >>>> happen when either device was probed. > >> >>>> > >> >>>> So, I think it's OK as it is. > >> >>> > >> >>> > >> >>> Surely you can do pm_runtime_get/put on the phy's parent platform > >> >>> device and do it that way? > >> >> could you please be more specific with that (do you mean pdev->dev.parent)? > >> >> so we would use pm_runtime_{get_sync,put} with the parent, while we > >> >> would still define the runtime_resume in our driver. > >> > > >> > You'd also need to do get/put on the children, but yes, that's what Ben > >> > is suggesting. > >> > > >> > However, the problem with all of the solutions proposed (runtime PM ones > >> > included) is that we're forcing a board-specific design issue (2 devices > >> > sharing a reset line) into a driver that should not have any > >> > board-specific assumptions in it. > >> > > >> > For example, if this driver is used on another platform where different > >> > PHYs have different reset lines, then one of them (the unlucky one who > >> > is not probed first) will never get reset. So any form of per-device > >> > ref-counting is not a portable solution. > >> indeed, so in simple words we would need something like > >> reset_control_do_once(rstc, RESET/ASSERT/DEASSERT) which would > >> remember internally if any action has already been executed: if not it > >> does a _reset, _assert or _deassert and otherwise it does nothing. > >> > >> > I'm not sure yet how the reset framework is supposed to handle shared > >> > reset lines, but that needs some investigation. I quick glance and it > >> > seems that reset controllers can have shared lines, so that should be > >> > investigated. > >> I added Philipp and Hans to this thread - maybe they can comment on this. > >> To sum it up, our problem is: > >> - there are two separate USB PHYs on Meson GXBB > >> - both are sharing the same reset line (provided by the reset-meson driver) > >> - during initialization of the PHYs we must only call > >> reset_control_reset(rstc) once (if we do it for the first *and* second > >> PHY then the first PHY gets confused once the second PHY uses the > >> reset because the first PHY's state is reset as well) > > > > If you have an initially asserted reset line and you can enable the > > first module by deasserting the reset via reset_control_deassert (and > > reset_control_assert to signal when the module may be disabled again > > after use), shared resets are for you. > > > > If you need a reset pulse or have no direct control over the reset line, > > (device_reset), the reset framework currently has no solution for this. > > The ugly thing about reset_control_once would be that it can't re-reset > > modules when unloading and reloading driver modules. > The corresponding reset driver in question is reset-meson, which only > implements reset (assert/deassert are not implemented). However, I > don't know if this is due to hardware design. > I think the hardware implements the latter, but maybe Neil can give > more information here (I currently don't have access to my board so I > cannot test how the hardware actually behaves). > > > A real solution for shared reset lines with reset pulses would have to > > be some kind of reset request framework where if one module requests a > > reset, the other module sharing the reset could be notified, and then > > either veto the reset or, if possible, cease operations, store its > > state, and prepare to be reset, too, and afterwards restore state. I'd > > prefer not to think about this too much unless absolutely necessary. > I'm not sure if this would work in our case: one PHY instance would > have to know if the other has already triggered the reset or not. We could add a triggered flag or a counter to struct reset_control, and have reset_control_reset_once do nothing if it is already set / incremented. Since the reset_control goes away with the last consumer, the shared reset line would get triggered again after unbinding both PHY devices. regards Philipp
Am Dienstag, den 13.09.2016, 17:59 -0700 schrieb Kevin Hilman: > Martin Blumenstingl <martin.blumenstingl@googlemail.com> writes: > > > On Tue, Sep 13, 2016 at 5:28 PM, Philipp Zabel <p.zabel@pengutronix.de> wrote: > > [...] > > >>> I added Philipp and Hans to this thread - maybe they can comment on this. > >>> To sum it up, our problem is: > >>> - there are two separate USB PHYs on Meson GXBB > >>> - both are sharing the same reset line (provided by the reset-meson driver) > >>> - during initialization of the PHYs we must only call > >>> reset_control_reset(rstc) once (if we do it for the first *and* second > >>> PHY then the first PHY gets confused once the second PHY uses the > >>> reset because the first PHY's state is reset as well) > >> > >> If you have an initially asserted reset line and you can enable the > >> first module by deasserting the reset via reset_control_deassert (and > >> reset_control_assert to signal when the module may be disabled again > >> after use), shared resets are for you. > >> > >> If you need a reset pulse or have no direct control over the reset line, > >> (device_reset), the reset framework currently has no solution for this. > >> The ugly thing about reset_control_once would be that it can't re-reset > >> modules when unloading and reloading driver modules. > > > > The corresponding reset driver in question is reset-meson, which only > > implements reset (assert/deassert are not implemented). However, I > > don't know if this is due to hardware design. > > I think the hardware implements the latter, but maybe Neil can give > > more information here (I currently don't have access to my board so I > > cannot test how the hardware actually behaves). > > It's implemented that way because the hardware only supports a reset > pulse. Would it be possible to bring down both PHYs drivers, pull the reset line once, and then bring the drivers back up again? regards Philipp
On Wed, Sep 14, 2016 at 10:37 AM, Philipp Zabel <p.zabel@pengutronix.de> wrote: > Am Dienstag, den 13.09.2016, 17:59 -0700 schrieb Kevin Hilman: >> Martin Blumenstingl <martin.blumenstingl@googlemail.com> writes: >> >> > On Tue, Sep 13, 2016 at 5:28 PM, Philipp Zabel <p.zabel@pengutronix.de> wrote: >> >> [...] >> >> >>> I added Philipp and Hans to this thread - maybe they can comment on this. >> >>> To sum it up, our problem is: >> >>> - there are two separate USB PHYs on Meson GXBB >> >>> - both are sharing the same reset line (provided by the reset-meson driver) >> >>> - during initialization of the PHYs we must only call >> >>> reset_control_reset(rstc) once (if we do it for the first *and* second >> >>> PHY then the first PHY gets confused once the second PHY uses the >> >>> reset because the first PHY's state is reset as well) >> >> >> >> If you have an initially asserted reset line and you can enable the >> >> first module by deasserting the reset via reset_control_deassert (and >> >> reset_control_assert to signal when the module may be disabled again >> >> after use), shared resets are for you. >> >> >> >> If you need a reset pulse or have no direct control over the reset line, >> >> (device_reset), the reset framework currently has no solution for this. >> >> The ugly thing about reset_control_once would be that it can't re-reset >> >> modules when unloading and reloading driver modules. >> > >> > The corresponding reset driver in question is reset-meson, which only >> > implements reset (assert/deassert are not implemented). However, I >> > don't know if this is due to hardware design. >> > I think the hardware implements the latter, but maybe Neil can give >> > more information here (I currently don't have access to my board so I >> > cannot test how the hardware actually behaves). >> >> It's implemented that way because the hardware only supports a reset >> pulse. > > Would it be possible to bring down both PHYs drivers, pull the reset > line once, and then bring the drivers back up again? I guess that this is the rmmod case: I haven't tested it yet but that should work (even with the current code and .dts)
On Wed, Sep 14, 2016 at 10:37 AM, Philipp Zabel <p.zabel@pengutronix.de> wrote: > Am Dienstag, den 13.09.2016, 20:38 +0200 schrieb Martin Blumenstingl: >> Hi Philipp, >> >> On Tue, Sep 13, 2016 at 5:28 PM, Philipp Zabel <p.zabel@pengutronix.de> wrote: >> > Hi Martin, >> > >> > Am Freitag, den 09.09.2016, 22:36 +0200 schrieb Martin Blumenstingl: >> >> On Fri, Sep 9, 2016 at 5:33 PM, Kevin Hilman <khilman@baylibre.com> wrote: >> >> > Martin Blumenstingl <martin.blumenstingl@googlemail.com> writes: >> >> > >> >> >> On Thu, Sep 8, 2016 at 10:53 PM, Ben Dooks <ben.dooks@codethink.co.uk> wrote: >> >> >>> On 08/09/16 21:42, Kevin Hilman wrote: >> >> >>>> >> >> >>>> Ben Dooks <ben.dooks@codethink.co.uk> writes: >> >> >>>> >> >> >>>>> On 08/09/16 20:52, Martin Blumenstingl wrote: >> >> >>>>>> >> >> >>>>>> On Thu, Sep 8, 2016 at 9:35 PM, Kevin Hilman <khilman@baylibre.com> >> >> >>>>>> wrote: >> >> >>>>>>>> >> >> >>>>>>>> + phy = devm_phy_create(&pdev->dev, NULL, &phy_meson_usb2_ops); >> >> >>>>>>>> + if (IS_ERR(phy)) { >> >> >>>>>>>> + dev_err(&pdev->dev, "failed to create PHY\n"); >> >> >>>>>>>> + return PTR_ERR(phy); >> >> >>>>>>>> + } >> >> >>>>>>>> + >> >> >>>>>>>> + if (usb_reset_refcnt++ == 0) { >> >> >>>>>>>> + ret = device_reset(&pdev->dev); >> >> >>>>>>>> + if (ret) { >> >> >>>>>>>> + dev_err(&phy->dev, "Failed to reset USB PHY\n"); >> >> >>>>>>>> + return ret; >> >> >>>>>>>> + } >> >> >>>>>>>> + } >> >> >>>>>>> >> >> >>>>>>> >> >> >>>>>>> The ref count + reset here looks like something that could/should be >> >> >>>>>>> handled in a runtime PM callback. >> >> >>>>>> >> >> >>>>>> Unfortunately that doesn't work (as Jerome found out) because both >> >> >>>>>> PHYs are sharing the same reset line. >> >> >>>>>> So if the second PHY would call device_reset then it would also reset >> >> >>>>>> the first PHY! >> >> >>>>>> >> >> >>>>>> There's a comment above the declaration of usb_reset_refcnt which >> >> >>>>>> tries to explain this: >> >> >>>>>> "The PHYs are sharing a common reset line -> we are only allowed to >> >> >>>>>> reset once for all PHYs." >> >> >>>>>> Maybe I should move this comment to the "if (usb_reset_refcnt++ == 0) >> >> >>>>>> {" line to make it easier to see? >> >> >>>>>> >> >> >>>>> >> >> >>>>> pm-runtime has refcounting in it. When one of the nodes turns on, >> >> >>>>> the pm-runtime will call your driver to say there is a user when >> >> >>>>> this first use turns up. >> >> >>>>> >> >> >>>>> If all the sub-phys turn off and drop their refcount then the driver >> >> >>>>> is called to say there are no more users and you can go to sleep. >> >> >>>> >> >> >>>> >> >> >>>> After a chat w/Martin on IRC, It turns out runtime PM wont help here. >> >> >>>> >> >> >>>> The reason is because there are physically two PHY devices[1]. Those 2 >> >> >>>> devices will be treated independely by runtime PM, and have separate >> >> >>>> use-counting, which means doing what I proposed would cause a reset to >> >> >>>> happen when either device was probed. >> >> >>>> >> >> >>>> So, I think it's OK as it is. >> >> >>> >> >> >>> >> >> >>> Surely you can do pm_runtime_get/put on the phy's parent platform >> >> >>> device and do it that way? >> >> >> could you please be more specific with that (do you mean pdev->dev.parent)? >> >> >> so we would use pm_runtime_{get_sync,put} with the parent, while we >> >> >> would still define the runtime_resume in our driver. >> >> > >> >> > You'd also need to do get/put on the children, but yes, that's what Ben >> >> > is suggesting. >> >> > >> >> > However, the problem with all of the solutions proposed (runtime PM ones >> >> > included) is that we're forcing a board-specific design issue (2 devices >> >> > sharing a reset line) into a driver that should not have any >> >> > board-specific assumptions in it. >> >> > >> >> > For example, if this driver is used on another platform where different >> >> > PHYs have different reset lines, then one of them (the unlucky one who >> >> > is not probed first) will never get reset. So any form of per-device >> >> > ref-counting is not a portable solution. >> >> indeed, so in simple words we would need something like >> >> reset_control_do_once(rstc, RESET/ASSERT/DEASSERT) which would >> >> remember internally if any action has already been executed: if not it >> >> does a _reset, _assert or _deassert and otherwise it does nothing. >> >> >> >> > I'm not sure yet how the reset framework is supposed to handle shared >> >> > reset lines, but that needs some investigation. I quick glance and it >> >> > seems that reset controllers can have shared lines, so that should be >> >> > investigated. >> >> I added Philipp and Hans to this thread - maybe they can comment on this. >> >> To sum it up, our problem is: >> >> - there are two separate USB PHYs on Meson GXBB >> >> - both are sharing the same reset line (provided by the reset-meson driver) >> >> - during initialization of the PHYs we must only call >> >> reset_control_reset(rstc) once (if we do it for the first *and* second >> >> PHY then the first PHY gets confused once the second PHY uses the >> >> reset because the first PHY's state is reset as well) >> > >> > If you have an initially asserted reset line and you can enable the >> > first module by deasserting the reset via reset_control_deassert (and >> > reset_control_assert to signal when the module may be disabled again >> > after use), shared resets are for you. >> > >> > If you need a reset pulse or have no direct control over the reset line, >> > (device_reset), the reset framework currently has no solution for this. >> > The ugly thing about reset_control_once would be that it can't re-reset >> > modules when unloading and reloading driver modules. >> The corresponding reset driver in question is reset-meson, which only >> implements reset (assert/deassert are not implemented). However, I >> don't know if this is due to hardware design. >> I think the hardware implements the latter, but maybe Neil can give >> more information here (I currently don't have access to my board so I >> cannot test how the hardware actually behaves). >> >> > A real solution for shared reset lines with reset pulses would have to >> > be some kind of reset request framework where if one module requests a >> > reset, the other module sharing the reset could be notified, and then >> > either veto the reset or, if possible, cease operations, store its >> > state, and prepare to be reset, too, and afterwards restore state. I'd >> > prefer not to think about this too much unless absolutely necessary. >> I'm not sure if this would work in our case: one PHY instance would >> have to know if the other has already triggered the reset or not. > > We could add a triggered flag or a counter to struct reset_control, and > have reset_control_reset_once do nothing if it is already set / > incremented. Since the reset_control goes away with the last consumer, > the shared reset line would get triggered again after unbinding both PHY > devices. I guess that'd do the trick for us: - we could use devm_reset_control_get_optional_shared() during probe - power_on would then call reset_control_reset() - the code in reset_control_reset would be changed: the if (WARN_ON(rstc->shared)) would be removed. then we return 0 if (rstc->shared && atomic_read(&rstc->shared_triggered)). otherwise we proceed with the old logic, except that we use atomic_set(&rstc->shared_triggerred, 1) in case of success (if an error was returned we leave it as "not triggered"). Let me know if you want me to (at least try to) implement that and send an RFC. Regards, Martin
Hi Martin, Am Mittwoch, den 14.09.2016, 23:23 +0200 schrieb Martin Blumenstingl: [...] > > We could add a triggered flag or a counter to struct reset_control, and > > have reset_control_reset_once do nothing if it is already set / > > incremented. Since the reset_control goes away with the last consumer, > > the shared reset line would get triggered again after unbinding both PHY > > devices. > I guess that'd do the trick for us: > - we could use devm_reset_control_get_optional_shared() during probe > - power_on would then call reset_control_reset() > - the code in reset_control_reset would be changed: the if > (WARN_ON(rstc->shared)) would be removed. then we return 0 if > (rstc->shared && atomic_read(&rstc->shared_triggered)). otherwise we > proceed with the old logic, except that we use > atomic_set(&rstc->shared_triggerred, 1) in case of success (if an > error was returned we leave it as "not triggered"). > > Let me know if you want me to (at least try to) implement that and send an RFC. Yes, please give it a try. reset_control_reset should still WARN if the deassert count is set, and reset_(de)assert should do so if triggered is set. Mixing the two won't work. And it should be documented that shared reset_control_reset may do nothing if the reset was already triggered by another consumer. regards Philipp
Hi, On Friday 09 September 2016 09:44 PM, Martin Blumenstingl wrote: > On Fri, Sep 9, 2016 at 5:33 PM, Kevin Hilman <khilman@baylibre.com> wrote: >> However, the problem with all of the solutions proposed (runtime PM ones >> included) is that we're forcing a board-specific design issue (2 devices >> sharing a reset line) into a driver that should not have any >> board-specific assumptions in it. >> >> For example, if this driver is used on another platform where different >> PHYs have different reset lines, then one of them (the unlucky one who >> is not probed first) will never get reset. So any form of per-device >> ref-counting is not a portable solution. > maybe we should also consider Ben's solution: he played with the USB > PHY on his Meson8b board. His approach was to have only one USB PHY > driver instance which exposes two PHYs. > The downside of this: the driver would have to know the offset of the > PHYs (0x0 for the first PHY, 0x20 for the second), but we could handle > the reset using runtime PM without any hacks. I think the offset information can come from the devicetree too. The phy can be modeled something like below. usb-phys@c0000000 { compatible = "amlogic,meson-gxbb-usb2-phy"; reg = <0x0 0xc0000000 0x0 0x40>; #address-cells = <2>; #size-cells = <2>; ranges = <0x0 0x0 0x0 0xc0000000 0x0 0x40>; resets = <&reset 34>; usb0_phy: usb_phy@0 { #phy-cells = <0>; reg = <0x0 0x0 0x0 0x20>; clocks = <&clkc CLKID_USB &clkc CLKID_USB0>; clock-names = "usb_general", "usb"; status = "disabled"; }; usb1_phy: usb_phy@20 { #phy-cells = <0>; reg = <0x0 0x20 0x0 0x20>; clocks = <&clkc CLKID_USB &clkc CLKID_USB1>; clock-names = "usb_general", "usb"; status = "disabled"; }; }; This way the driver will be probed only once (the reset can be done during probe). The phy driver should scan the dt node and for every sub-node it invokes phy_create? Thanks Kishon
On Friday, September 16, 2016 1:49:59 PM CEST Kishon Vijay Abraham I wrote: > > I think the offset information can come from the devicetree too. The phy can be > modeled something like below. > > usb-phys@c0000000 { > compatible = "amlogic,meson-gxbb-usb2-phy"; > reg = <0x0 0xc0000000 0x0 0x40>; > #address-cells = <2>; > #size-cells = <2>; > ranges = <0x0 0x0 0x0 0xc0000000 0x0 0x40>; > resets = <&reset 34>; > > usb0_phy: usb_phy@0 { > #phy-cells = <0>; > reg = <0x0 0x0 0x0 0x20>; > clocks = <&clkc CLKID_USB &clkc CLKID_USB0>; > clock-names = "usb_general", "usb"; > status = "disabled"; > }; > > usb1_phy: usb_phy@20 { > #phy-cells = <0>; > reg = <0x0 0x20 0x0 0x20>; > clocks = <&clkc CLKID_USB &clkc CLKID_USB1>; > clock-names = "usb_general", "usb"; > status = "disabled"; > }; > }; > > This way the driver will be probed only once (the reset can be done during > probe). The phy driver should scan the dt node and for every sub-node it > invokes phy_create? Why not just use #phy-cells=<1> and pass the phy number as an argument in the reference? Arnd
Hi Kishon, On Fri, Sep 16, 2016 at 10:19 AM, Kishon Vijay Abraham I <kishon@ti.com> wrote: > Hi, > > On Friday 09 September 2016 09:44 PM, Martin Blumenstingl wrote: >> On Fri, Sep 9, 2016 at 5:33 PM, Kevin Hilman <khilman@baylibre.com> wrote: >>> However, the problem with all of the solutions proposed (runtime PM ones >>> included) is that we're forcing a board-specific design issue (2 devices >>> sharing a reset line) into a driver that should not have any >>> board-specific assumptions in it. >>> >>> For example, if this driver is used on another platform where different >>> PHYs have different reset lines, then one of them (the unlucky one who >>> is not probed first) will never get reset. So any form of per-device >>> ref-counting is not a portable solution. >> maybe we should also consider Ben's solution: he played with the USB >> PHY on his Meson8b board. His approach was to have only one USB PHY >> driver instance which exposes two PHYs. >> The downside of this: the driver would have to know the offset of the >> PHYs (0x0 for the first PHY, 0x20 for the second), but we could handle >> the reset using runtime PM without any hacks. > > I think the offset information can come from the devicetree too. The phy can be > modeled something like below. > > usb-phys@c0000000 { > compatible = "amlogic,meson-gxbb-usb2-phy"; > reg = <0x0 0xc0000000 0x0 0x40>; > #address-cells = <2>; > #size-cells = <2>; > ranges = <0x0 0x0 0x0 0xc0000000 0x0 0x40>; > resets = <&reset 34>; > > usb0_phy: usb_phy@0 { > #phy-cells = <0>; > reg = <0x0 0x0 0x0 0x20>; > clocks = <&clkc CLKID_USB &clkc CLKID_USB0>; > clock-names = "usb_general", "usb"; > status = "disabled"; > }; > > usb1_phy: usb_phy@20 { > #phy-cells = <0>; > reg = <0x0 0x20 0x0 0x20>; > clocks = <&clkc CLKID_USB &clkc CLKID_USB1>; > clock-names = "usb_general", "usb"; > status = "disabled"; > }; > }; > > This way the driver will be probed only once (the reset can be done during > probe). The phy driver should scan the dt node and for every sub-node it > invokes phy_create? I'll recap what we have discussed so far (so you don't have to re-read the whole thread): The reference driver treats both USB PHYs as separate devices (the datasheet has no information about the PHYs though). The only "special" thing is the shared reset line -> together with Philipp Zabel (the reset framework maintainer) we decided to make reset_control_reset work for shared reset lines. That means we can keep the two PHYs as separate devices inside the .dts, while keeping everything else separate (just like the reference driver) Is this fine for you and Arnd? Regards, Martin
Hi, On Monday 19 September 2016 01:26 AM, Martin Blumenstingl wrote: > Hi Kishon, > > On Fri, Sep 16, 2016 at 10:19 AM, Kishon Vijay Abraham I <kishon@ti.com> wrote: >> Hi, >> >> On Friday 09 September 2016 09:44 PM, Martin Blumenstingl wrote: >>> On Fri, Sep 9, 2016 at 5:33 PM, Kevin Hilman <khilman@baylibre.com> wrote: >>>> However, the problem with all of the solutions proposed (runtime PM ones >>>> included) is that we're forcing a board-specific design issue (2 devices >>>> sharing a reset line) into a driver that should not have any >>>> board-specific assumptions in it. >>>> >>>> For example, if this driver is used on another platform where different >>>> PHYs have different reset lines, then one of them (the unlucky one who >>>> is not probed first) will never get reset. So any form of per-device >>>> ref-counting is not a portable solution. >>> maybe we should also consider Ben's solution: he played with the USB >>> PHY on his Meson8b board. His approach was to have only one USB PHY >>> driver instance which exposes two PHYs. >>> The downside of this: the driver would have to know the offset of the >>> PHYs (0x0 for the first PHY, 0x20 for the second), but we could handle >>> the reset using runtime PM without any hacks. >> >> I think the offset information can come from the devicetree too. The phy can be >> modeled something like below. >> >> usb-phys@c0000000 { >> compatible = "amlogic,meson-gxbb-usb2-phy"; >> reg = <0x0 0xc0000000 0x0 0x40>; >> #address-cells = <2>; >> #size-cells = <2>; >> ranges = <0x0 0x0 0x0 0xc0000000 0x0 0x40>; >> resets = <&reset 34>; >> >> usb0_phy: usb_phy@0 { >> #phy-cells = <0>; >> reg = <0x0 0x0 0x0 0x20>; >> clocks = <&clkc CLKID_USB &clkc CLKID_USB0>; >> clock-names = "usb_general", "usb"; >> status = "disabled"; >> }; >> >> usb1_phy: usb_phy@20 { >> #phy-cells = <0>; >> reg = <0x0 0x20 0x0 0x20>; >> clocks = <&clkc CLKID_USB &clkc CLKID_USB1>; >> clock-names = "usb_general", "usb"; >> status = "disabled"; >> }; >> }; >> >> This way the driver will be probed only once (the reset can be done during >> probe). The phy driver should scan the dt node and for every sub-node it >> invokes phy_create? > I'll recap what we have discussed so far (so you don't have to re-read > the whole thread): > The reference driver treats both USB PHYs as separate devices (the > datasheet has no information about the PHYs though). The only > "special" thing is the shared reset line -> together with Philipp > Zabel (the reset framework maintainer) we decided to make > reset_control_reset work for shared reset lines. > > That means we can keep the two PHYs as separate devices inside the > .dts, while keeping everything else separate (just like the reference > driver) > Is this fine for you and Arnd? yeah.. I'm fine with that. Thanks Kishon > > > Regards, > Martin >
On Monday, September 19, 2016 10:29:27 AM CEST Kishon Vijay Abraham I wrote: > On Monday 19 September 2016 01:26 AM, Martin Blumenstingl wrote: > > On Fri, Sep 16, 2016 at 10:19 AM, Kishon Vijay Abraham I <kishon@ti.com> wrote: > >> This way the driver will be probed only once (the reset can be done during > >> probe). The phy driver should scan the dt node and for every sub-node it > >> invokes phy_create? > > I'll recap what we have discussed so far (so you don't have to re-read > > the whole thread): > > The reference driver treats both USB PHYs as separate devices (the > > datasheet has no information about the PHYs though). The only > > "special" thing is the shared reset line -> together with Philipp > > Zabel (the reset framework maintainer) we decided to make > > reset_control_reset work for shared reset lines. > > > > That means we can keep the two PHYs as separate devices inside the > > .dts, while keeping everything else separate (just like the reference > > driver) > > Is this fine for you and Arnd? > > yeah.. I'm fine with that. > Agreed, if we don't need to have a device modeled around both instance, that's ideal. Arnd
diff --git a/arch/arm64/boot/dts/amlogic/meson-gxbb.dtsi b/arch/arm64/boot/dts/amlogic/meson-gxbb.dtsi index 2e8a3d9..02dfc54 100644 --- a/arch/arm64/boot/dts/amlogic/meson-gxbb.dtsi +++ b/arch/arm64/boot/dts/amlogic/meson-gxbb.dtsi @@ -151,6 +151,34 @@ #size-cells = <2>; ranges; + usb-phys@c0000000 { + compatible = "simple-bus"; + reg = <0x0 0xc0000000 0x0 0x40>; + #address-cells = <2>; + #size-cells = <2>; + ranges = <0x0 0x0 0x0 0xc0000000 0x0 0x40>; + + usb0_phy: usb_phy@0 { + compatible = "amlogic,meson-gxbb-usb2-phy"; + #phy-cells = <0>; + reg = <0x0 0x0 0x0 0x20>; + resets = <&reset 34>; + clocks = <&clkc CLKID_USB &clkc CLKID_USB0>; + clock-names = "usb_general", "usb"; + status = "disabled"; + }; + + usb1_phy: usb_phy@20 { + compatible = "amlogic,meson-gxbb-usb2-phy"; + #phy-cells = <0>; + reg = <0x0 0x20 0x0 0x20>; + resets = <&reset 34>; + clocks = <&clkc CLKID_USB &clkc CLKID_USB1>; + clock-names = "usb_general", "usb"; + status = "disabled"; + }; + }; + _______________________________________________ linux-arm-kernel mailing list