| Message ID | 20200716132120.1.I01e738cd469b61fc9b28b3ef1c6541a4f48b11bf@changeid (mailing list archive) |
|---|---|
| State | Accepted |
| Commit | 667d73d72f3188909914c60e97a1db33edc21971 |
| Headers | show |
| Series | drm: panel: simple: Delay HPD checking on boe_nv133fhm_n61 for 15 ms | expand |
On Thu 16 Jul 13:21 PDT 2020, Douglas Anderson wrote: > On boe_nv133fhm_n62 (and presumably on boe_nv133fhm_n61) a scope shows > a small spike on the HPD line right when you power the panel on. The > picture looks something like this: > > +-------------------------------------- > | > | > | > Power ---+ > +--- > | > ++ | > +----+| | > HPD -----+ +---------------------------+ > > So right when power is applied there's a little bump in HPD and then > there's small spike right before it goes low. The total time of the > little bump plus the spike was measured on one panel as being 8 ms > long. The total time for the HPD to go high on the same panel was > 51.2 ms, though the datasheet only promises it is < 200 ms. > > When asked about this glitch, BOE indicated that it was expected and > persisted until the TCON has been initialized. > > If this was a real hotpluggable DP panel then this wouldn't matter a > whole lot. We'd debounce the HPD signal for a really long time and so > the little blip wouldn't hurt. However, this is not a hotpluggable DP > panel and the the debouncing logic isn't needed and just shows down > the time needed to get the display working. This is why the code in > panel_simple_prepare() doesn't do debouncing and just waits for HPD to > go high once. Unfortunately if we get unlucky and happen to poll the > HPD line right at the spike we can try talking to the panel before > it's ready. > > Let's handle this situation by putting in a 15 ms prepare delay and > decreasing the "hpd absent delay" by 15 ms. That means: > * If you don't have HPD hooked up at all you've still got the > hardcoded 200 ms delay. > * If you've got HPD hooked up you will always wait at least 15 ms > before checking HPD. The only case where this could be bad is if > the panel is sharing a voltage rail with something else in the > system and was already turned on long before the panel came up. In > such a case we'll be delaying 15 ms for no reason, but it's not a > huge delay and I don't see any other good solution to handle that > case. > > Even though the delay was measured as 8 ms, 15 ms was chosen to give a > bit of margin. > Reviewed-by: Bjorn Andersson <bjorn.andersson@linaro.org> > Signed-off-by: Douglas Anderson <dianders@chromium.org> > --- > I don't actually have a device in front of me that is exhibiting these > problems. I believe that it is only some devices and some of the > time. Still, this patch seems safe and seems likely to fix the issue > given the scope shots. > > drivers/gpu/drm/panel/panel-simple.c | 16 +++++++++++++++- > 1 file changed, 15 insertions(+), 1 deletion(-) > > diff --git a/drivers/gpu/drm/panel/panel-simple.c b/drivers/gpu/drm/panel/panel-simple.c > index 88493538a147..046a06b55800 100644 > --- a/drivers/gpu/drm/panel/panel-simple.c > +++ b/drivers/gpu/drm/panel/panel-simple.c > @@ -1260,7 +1260,21 @@ static const struct panel_desc boe_nv133fhm_n61 = { > .height = 165, > }, > .delay = { > - .hpd_absent_delay = 200, > + /* > + * When power is first given to the panel there's a short > + * spike on the HPD line. It was explained that this spike > + * was until the TCON data download was complete. On > + * one system this was measured at 8 ms. We'll put 15 ms > + * in the prepare delay just to be safe and take it away > + * from the hpd_absent_delay (which would otherwise be 200 ms) > + * to handle this. That means: > + * - If HPD isn't hooked up you still have 200 ms delay. > + * - If HPD is hooked up we won't try to look at it for the > + * first 15 ms. > + */ > + .prepare = 15, > + .hpd_absent_delay = 185, > + > .unprepare = 500, > }, > .bus_format = MEDIA_BUS_FMT_RGB888_1X24, > -- > 2.28.0.rc0.105.gf9edc3c819-goog >
Hi, On Thu, Jul 16, 2020 at 1:21 PM Douglas Anderson <dianders@chromium.org> wrote: > > On boe_nv133fhm_n62 (and presumably on boe_nv133fhm_n61) a scope shows > a small spike on the HPD line right when you power the panel on. The > picture looks something like this: > > +-------------------------------------- > | > | > | > Power ---+ > +--- > | > ++ | > +----+| | > HPD -----+ +---------------------------+ > > So right when power is applied there's a little bump in HPD and then > there's small spike right before it goes low. The total time of the > little bump plus the spike was measured on one panel as being 8 ms > long. The total time for the HPD to go high on the same panel was > 51.2 ms, though the datasheet only promises it is < 200 ms. > > When asked about this glitch, BOE indicated that it was expected and > persisted until the TCON has been initialized. > > If this was a real hotpluggable DP panel then this wouldn't matter a > whole lot. We'd debounce the HPD signal for a really long time and so > the little blip wouldn't hurt. However, this is not a hotpluggable DP > panel and the the debouncing logic isn't needed and just shows down > the time needed to get the display working. This is why the code in > panel_simple_prepare() doesn't do debouncing and just waits for HPD to > go high once. Unfortunately if we get unlucky and happen to poll the > HPD line right at the spike we can try talking to the panel before > it's ready. > > Let's handle this situation by putting in a 15 ms prepare delay and > decreasing the "hpd absent delay" by 15 ms. That means: > * If you don't have HPD hooked up at all you've still got the > hardcoded 200 ms delay. > * If you've got HPD hooked up you will always wait at least 15 ms > before checking HPD. The only case where this could be bad is if > the panel is sharing a voltage rail with something else in the > system and was already turned on long before the panel came up. In > such a case we'll be delaying 15 ms for no reason, but it's not a > huge delay and I don't see any other good solution to handle that > case. > > Even though the delay was measured as 8 ms, 15 ms was chosen to give a > bit of margin. > > Signed-off-by: Douglas Anderson <dianders@chromium.org> > --- > I don't actually have a device in front of me that is exhibiting these > problems. I believe that it is only some devices and some of the > time. Still, this patch seems safe and seems likely to fix the issue > given the scope shots. Just to follow-up, I just heard that someone who had a panel exhibiting this problem tried my patch and it fixed it for them. :-) So this is not such a shot in the dark anymore. -Doug
On Thu, Jul 16, 2020 at 01:21:22PM -0700, Douglas Anderson wrote: > On boe_nv133fhm_n62 (and presumably on boe_nv133fhm_n61) a scope shows > a small spike on the HPD line right when you power the panel on. The > picture looks something like this: > > +-------------------------------------- > | > | > | > Power ---+ > +--- > | > ++ | > +----+| | > HPD -----+ +---------------------------+ > > So right when power is applied there's a little bump in HPD and then > there's small spike right before it goes low. The total time of the > little bump plus the spike was measured on one panel as being 8 ms > long. The total time for the HPD to go high on the same panel was > 51.2 ms, though the datasheet only promises it is < 200 ms. > > When asked about this glitch, BOE indicated that it was expected and > persisted until the TCON has been initialized. > > If this was a real hotpluggable DP panel then this wouldn't matter a > whole lot. We'd debounce the HPD signal for a really long time and so > the little blip wouldn't hurt. However, this is not a hotpluggable DP > panel and the the debouncing logic isn't needed and just shows down > the time needed to get the display working. This is why the code in > panel_simple_prepare() doesn't do debouncing and just waits for HPD to > go high once. Unfortunately if we get unlucky and happen to poll the > HPD line right at the spike we can try talking to the panel before > it's ready. > > Let's handle this situation by putting in a 15 ms prepare delay and > decreasing the "hpd absent delay" by 15 ms. That means: > * If you don't have HPD hooked up at all you've still got the > hardcoded 200 ms delay. > * If you've got HPD hooked up you will always wait at least 15 ms > before checking HPD. The only case where this could be bad is if > the panel is sharing a voltage rail with something else in the > system and was already turned on long before the panel came up. In > such a case we'll be delaying 15 ms for no reason, but it's not a > huge delay and I don't see any other good solution to handle that > case. > > Even though the delay was measured as 8 ms, 15 ms was chosen to give a > bit of margin. > > Signed-off-by: Douglas Anderson <dianders@chromium.org> Nice drawing and good explanation. Applied to drm-misc-fixes. Sam > --- > I don't actually have a device in front of me that is exhibiting these > problems. I believe that it is only some devices and some of the > time. Still, this patch seems safe and seems likely to fix the issue > given the scope shots. > > drivers/gpu/drm/panel/panel-simple.c | 16 +++++++++++++++- > 1 file changed, 15 insertions(+), 1 deletion(-) > > diff --git a/drivers/gpu/drm/panel/panel-simple.c b/drivers/gpu/drm/panel/panel-simple.c > index 88493538a147..046a06b55800 100644 > --- a/drivers/gpu/drm/panel/panel-simple.c > +++ b/drivers/gpu/drm/panel/panel-simple.c > @@ -1260,7 +1260,21 @@ static const struct panel_desc boe_nv133fhm_n61 = { > .height = 165, > }, > .delay = { > - .hpd_absent_delay = 200, > + /* > + * When power is first given to the panel there's a short > + * spike on the HPD line. It was explained that this spike > + * was until the TCON data download was complete. On > + * one system this was measured at 8 ms. We'll put 15 ms > + * in the prepare delay just to be safe and take it away > + * from the hpd_absent_delay (which would otherwise be 200 ms) > + * to handle this. That means: > + * - If HPD isn't hooked up you still have 200 ms delay. > + * - If HPD is hooked up we won't try to look at it for the > + * first 15 ms. > + */ > + .prepare = 15, > + .hpd_absent_delay = 185, > + > .unprepare = 500, > }, > .bus_format = MEDIA_BUS_FMT_RGB888_1X24, > -- > 2.28.0.rc0.105.gf9edc3c819-goog > > _______________________________________________ > dri-devel mailing list > dri-devel@lists.freedesktop.org > https://lists.freedesktop.org/mailman/listinfo/dri-devel
diff --git a/drivers/gpu/drm/panel/panel-simple.c b/drivers/gpu/drm/panel/panel-simple.c index 88493538a147..046a06b55800 100644 --- a/drivers/gpu/drm/panel/panel-simple.c +++ b/drivers/gpu/drm/panel/panel-simple.c @@ -1260,7 +1260,21 @@ static const struct panel_desc boe_nv133fhm_n61 = { .height = 165, }, .delay = { - .hpd_absent_delay = 200, + /* + * When power is first given to the panel there's a short + * spike on the HPD line. It was explained that this spike + * was until the TCON data download was complete. On + * one system this was measured at 8 ms. We'll put 15 ms + * in the prepare delay just to be safe and take it away + * from the hpd_absent_delay (which would otherwise be 200 ms) + * to handle this. That means: + * - If HPD isn't hooked up you still have 200 ms delay. + * - If HPD is hooked up we won't try to look at it for the + * first 15 ms. + */ + .prepare = 15, + .hpd_absent_delay = 185, + .unprepare = 500, }, .bus_format = MEDIA_BUS_FMT_RGB888_1X24,
On boe_nv133fhm_n62 (and presumably on boe_nv133fhm_n61) a scope shows a small spike on the HPD line right when you power the panel on. The picture looks something like this: +-------------------------------------- | | | Power ---+ +--- | ++ | +----+| | HPD -----+ +---------------------------+ So right when power is applied there's a little bump in HPD and then there's small spike right before it goes low. The total time of the little bump plus the spike was measured on one panel as being 8 ms long. The total time for the HPD to go high on the same panel was 51.2 ms, though the datasheet only promises it is < 200 ms. When asked about this glitch, BOE indicated that it was expected and persisted until the TCON has been initialized. If this was a real hotpluggable DP panel then this wouldn't matter a whole lot. We'd debounce the HPD signal for a really long time and so the little blip wouldn't hurt. However, this is not a hotpluggable DP panel and the the debouncing logic isn't needed and just shows down the time needed to get the display working. This is why the code in panel_simple_prepare() doesn't do debouncing and just waits for HPD to go high once. Unfortunately if we get unlucky and happen to poll the HPD line right at the spike we can try talking to the panel before it's ready. Let's handle this situation by putting in a 15 ms prepare delay and decreasing the "hpd absent delay" by 15 ms. That means: * If you don't have HPD hooked up at all you've still got the hardcoded 200 ms delay. * If you've got HPD hooked up you will always wait at least 15 ms before checking HPD. The only case where this could be bad is if the panel is sharing a voltage rail with something else in the system and was already turned on long before the panel came up. In such a case we'll be delaying 15 ms for no reason, but it's not a huge delay and I don't see any other good solution to handle that case. Even though the delay was measured as 8 ms, 15 ms was chosen to give a bit of margin. Signed-off-by: Douglas Anderson <dianders@chromium.org> --- I don't actually have a device in front of me that is exhibiting these problems. I believe that it is only some devices and some of the time. Still, this patch seems safe and seems likely to fix the issue given the scope shots. drivers/gpu/drm/panel/panel-simple.c | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-)