[lkml]   [2020]   [Mar]   [4]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
Messages in this thread
SubjectRe: [PATCH v10 2/3] soc: qcom: rpmh: Update dirty flag only when data changes

On Tue, Mar 3, 2020 at 4:27 AM Maulik Shah <> wrote:
> Currently rpmh ctrlr dirty flag is set for all cases regardless of data
> is really changed or not. Add changes to update dirty flag when data is
> changed to newer values. Update dirty flag everytime when data in batch
> cache is updated since rpmh_flush() may get invoked from any CPU instead
> of only last CPU going to low power mode.
> Also move dirty flag updates to happen from within cache_lock and remove
> unnecessary INIT_LIST_HEAD() call and a default case from switch.
> Fixes: 600513dfeef3 ("drivers: qcom: rpmh: cache sleep/wake state requests")
> Signed-off-by: Maulik Shah <>
> Reviewed-by: Srinivas Rao L <>
> Reviewed-by: Evan Green <>
> ---
> drivers/soc/qcom/rpmh.c | 21 +++++++++++++--------
> 1 file changed, 13 insertions(+), 8 deletions(-)
> diff --git a/drivers/soc/qcom/rpmh.c b/drivers/soc/qcom/rpmh.c
> index eb0ded0..f28afe4 100644
> --- a/drivers/soc/qcom/rpmh.c
> +++ b/drivers/soc/qcom/rpmh.c
> @@ -133,26 +133,30 @@ static struct cache_req *cache_rpm_request(struct rpmh_ctrlr *ctrlr,
> req->addr = cmd->addr;
> req->sleep_val = req->wake_val = UINT_MAX;
> - INIT_LIST_HEAD(&req->list);
> list_add_tail(&req->list, &ctrlr->cache);
> existing:
> switch (state) {
> - if (req->sleep_val != UINT_MAX)
> + if (req->sleep_val != UINT_MAX) {
> req->wake_val = cmd->data;
> + ctrlr->dirty = true;
> + }

You could maybe avoid a few additional "dirty" cases by changing the
above "if" to:

if (req->sleep_val != UINT_MAX &&
(req->wake_val != cmd->data)

...since otherwise writing an "ACTIVE_ONLY" thing over and over again
with the same value would keep saying "dirty".

Looking at this code makes me wonder a bit about how it's supposed to
work, though. Let's look at a sequence of 3 commands called in two
different orders:

rpmh_write(RPMH_WAKE_ONLY_STATE, addr=0x10, data=0xaa);
rpmh_write(RPMH_ACTIVE_ONLY_STATE, addr=0x10, data=0x99);
rpmh_write(RPMH_SLEEP_STATE, addr=0x10, data=0xbb);

==> End result will be a cache entry (addr=0x10, wake=0xaa, sleep=0xbb)

rpmh_write(RPMH_SLEEP_STATE, addr=0x10, data=0xbb);
rpmh_write(RPMH_WAKE_ONLY_STATE, addr=0x10, data=0xaa);
rpmh_write(RPMH_ACTIVE_ONLY_STATE, addr=0x10, data=0x99);

==> End result will be a cache entry (addr=0x10, wake=0x99, sleep=0xbb)

Said another way, it seems weird that a vote for "active" counts as a
vote for "wake", but only if a sleep vote was made beforehand?

Maybe at one point in time it was assumed that wake's point was just
to undo sleep? That is, if:

state_orig = /* the state before sleep happens */
state_sleep = apply(state_orig, sleep_actions)
state_wake = apply(state_sleep, wake_actions)

The code is assuming "state_orig == state_wake". sorta makes sense that "state_orig == state_wake" would be true,
but if we were really making that requirement we really should have
structured RPMH's APIs differently. We shouldn't have even allowed
the callers to specify "WAKE_ONLY" state and we should have just
constructed it from the "ACTIVE_ONLY" state.

To summarize:

a) If the only allowable use of "WAKE_ONLY" is to undo "SLEEP_ONLY"
then we should re-think the API and stop letting callers to
rpmh_write(), rpmh_write_async(), or rpmh_write_batch() ever specify
"WAKE_ONLY". The code should just assume that "wake_only =
active_only if (active_only != sleep_only)". In other words, RPMH
should programmatically figure out the "wake" state based on the
sleep/active state and not force callers to do this.

b) If "WAKE_ONLY" is allowed to do other things (or if it's not RPMH's
job to enforce/assume this) then we should fully skip calling
cache_rpm_request() for RPMH_ACTIVE_ONLY_STATE.

NOTE: this discussion also makes me wonder about the is_req_valid()
function. That will skip sending a sleep/wake entry if the sleep and
wake entries are equal to each other. ...but if sleep and wake are
both different than "active" it'll be a problem.

> break;
> - req->wake_val = cmd->data;
> + if (req->wake_val != cmd->data) {
> + req->wake_val = cmd->data;
> + ctrlr->dirty = true;

As far as I can tell from the code, you can also avoid dirty if
req->sleep_val == UINT_MAX since nothing will be sent if either
sleep_val or wake_val are UINT_MAX. Same in the sleep case where we
can avoid dirty if wake_val == UINT_MAX.

> + }
> break;
> - req->sleep_val = cmd->data;
> - break;
> - default:
> + if (req->sleep_val != cmd->data) {
> + req->sleep_val = cmd->data;
> + ctrlr->dirty = true;
> + }
> break;
> }

I wonder if instead of putting the dirty everywhere above it's better
to cache the old value before the switch, then do:

ctrl->dirty = (req->sleep_val != old_sleep_val ||
req->wake_val != old_wake_val) &&
req->sleep_val != UINT_MAX &&
req->wake_val != UINT_MAX;


 \ /
  Last update: 2020-03-05 00:22    [W:0.123 / U:1.560 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site