drivers/qcom: add additional functionality to RPMH
Subsystems (2)
v2 cover drivers/qcom: add additional functionality to RPMH
From: "Raju P.L.S.S.S.N" <[email protected]>
Changes in v1:
- Remove unnecessary EXPORT_SYMBOL in rpmh-rsc
This set of patches add additional functionality to RPMH drivers[1].
PM drivers can choose to disallow idle modes when RSC controller is busy sending or processing requests. The patches add necessary functions to query the controller status.
The controllers may be in 'solver' state, where they could be in autonomous mode executing low power modes for their hardware and as such are not available for sending active votes. Functionality to get notified about such state and disallow requests for state change in that case is added in these patches.
The Power Domain Controller can be programmed to wakeup the RSC and setup the resources back in the active state, before the processor is woken up by a timer interrupt. The wakeup value from the timer hardware can be copied to the PDC which has its own timer and is in an always-on power domain. Programming the wakeup value is done through a separate register on the RSC. Functions necessary to program wakeup is added in the patches.
Please consider reviewing this patchset.
v1:https://lkml.org/lkml/2018/7/19/213
[1] https://lkml.org/lkml/2018/6/20/519
Lina Iyer (5):
drivers: qcom: rpmh-rsc: return if the controller is idle
drivers: qcom: rpmh: export controller idle status
drivers: qcom: rpmh: disallow active requests in solver mode
drivers: qcom: rpmh-rsc: write PDC data
drivers: qcom: rpmh: write PDC data
Raju P.L.S.S.S.N (1):
drivers: qcom: rpmh-rsc: clear active mode configuration for waketcs
drivers/soc/qcom/rpmh-internal.h | 6 ++ drivers/soc/qcom/rpmh-rsc.c | 132 ++++++++++++++++++++++++++++++--------- drivers/soc/qcom/rpmh.c | 100 +++++++++++++++++++++++++++++ include/soc/qcom/rpmh.h | 16 +++++ 4 files changed, 225 insertions(+), 29 deletions(-)
Signature · 1 line
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,\na Linux Foundation Collaborative Project
PATCH v2 1/6 drivers: qcom: rpmh-rsc: return if the controller is idle
From: Lina Iyer <[email protected]>
Allow the controller status be queried. The controller is busy if it is actively processing request.
---
Changes in v2:
- Remove unnecessary EXPORT_SYMBOL
--- drivers/soc/qcom/rpmh-internal.h | 1 + drivers/soc/qcom/rpmh-rsc.c | 20 ++++++++++++++++++++ 2 files changed, 21 insertions(+)
drivers/soc/qcom/rpmh-internal.h +1 -0
@@ -108,6 +108,7 @@ struct rsc_drv {int rpmh_rsc_write_ctrl_data (struct rsc_drv *drv,const struct tcs_request *msg);int rpmh_rsc_invalidate (struct rsc_drv *drv); +bool rpmh_rsc_ctrlr_is_idle (struct rsc_drv *drv);void rpmh_tx_done (const struct tcs_request *msg,int r);
drivers/soc/qcom/rpmh-rsc.c +20 -0
@@ -496,6 +496,26 @@ static int tcs_ctrl_write(struct rsc_drv *drv, const struct tcs_request *msg) }/** +* rpmh_rsc_ctrlr_is_idle: Check if any of the AMCs are busy. +* +* @drv: The controller +* +* Returns true if the TCSes are engaged in handling requests. +*/ +bool rpmh_rsc_ctrlr_is_idle (struct rsc_drv *drv) +{ +int m; +struct tcs_group *tcs =get_tcs_of_type (drv,ACTIVE_TCS ); + +for (m = tcs->offset; m < tcs->offset + tcs->num_tcs; m++) { +if (!tcs_is_free (drv, m)) +return false; + } + +return true; +} + +/** * rpmh_rsc_write_ctrl_data: Write request to the controller * * @drv: the controller
Signature · 1 line
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,\na Linux Foundation Collaborative Project
Re: [PATCH v2 1/6] drivers: qcom: rpmh-rsc: return if the controller is idle
Hi Raju/Lina,
Quoted 43 lines · Raju P L S S S N
From: Lina Iyer <[email protected]>
Allow the controller status be queried. The controller is busy if it is actively processing request.
Signed-off-by Lina Iyer <[email protected]>Signed-off-by Raju P.L.S.S.S.N <[email protected]>---
Changes in v2:
- Remove unnecessaryEXPORT_SYMBOL--- drivers/soc/qcom/rpmh-internal.h | 1 + drivers/soc/qcom/rpmh-rsc.c | 20 ++++++++++++++++++++ 2 files changed, 21 insertions(+)drivers/soc/qcom/rpmh-internal.h +1
-0@@ -108,6 +108,7 @@ struct rsc_drv {int rpmh_rsc_write_ctrl_data (struct rsc_drv *drv,const struct tcs_request *msg);int rpmh_rsc_invalidate (struct rsc_drv *drv); +bool rpmh_rsc_ctrlr_is_idle (struct rsc_drv *drv);void rpmh_tx_done (const struct tcs_request *msg,int r);drivers/soc/qcom/rpmh-rsc.c +8
-0@@ -496,6 +496,26 @@ static int tcs_ctrl_write(struct rsc_drv *drv, const struct tcs_request *msg) }/** +* rpmh_rsc_ctrlr_is_idle: Check if any of the AMCs are busy. +* +* @drv: The controller +* +* Returns true if the TCSes are engaged in handling requests. +*/ +bool rpmh_rsc_ctrlr_is_idle (struct rsc_drv *drv) +{
drivers/soc/qcom/rpmh-rsc.c static int tcs_ctrl_write(struct rsc_drv *drv, const struct tcs_request *msg) · line 516
Quoted 10 lines
drivers/soc/qcom/rpmh-rsc.c +10
-0+int m; +struct tcs_group *tcs =get_tcs_of_type (drv,ACTIVE_TCS ); + +for (m = tcs->offset; m < tcs->offset + tcs->num_tcs; m++) { +if (!tcs_is_free (drv, m)) +return false; + } + +return true; +}
This looks racy, tcs_write() could be running simultaneously and use TCSes that were seen as free by _is_idle(). This could be fixed by holding tcs->lock (assuming this doesn't cause lock ordering problems). However even with this tcs_write() could run right after releasing the lock, using TCSes and the caller of _is_idle() would consider the controller to be idle.
Re: [PATCH v2 1/6] drivers: qcom: rpmh-rsc: return if the controller is idle
Quoted 55 lines · Matthias Kaehlcke
Hi Raju/Lina,
Quoted 52 lines · Raju P L S S S N
From: Lina Iyer <[email protected]>
Allow the controller status be queried. The controller is busy if it is actively processing request.
Signed-off-by Lina Iyer <[email protected]>Signed-off-by Raju P.L.S.S.S.N <[email protected]>---
Changes in v2:
- Remove unnecessaryEXPORT_SYMBOL--- drivers/soc/qcom/rpmh-internal.h | 1 + drivers/soc/qcom/rpmh-rsc.c | 20 ++++++++++++++++++++ 2 files changed, 21 insertions(+)drivers/soc/qcom/rpmh-internal.h +1
-0@@ -108,6 +108,7 @@ struct rsc_drv {int rpmh_rsc_write_ctrl_data (struct rsc_drv *drv,const struct tcs_request *msg);int rpmh_rsc_invalidate (struct rsc_drv *drv); +bool rpmh_rsc_ctrlr_is_idle (struct rsc_drv *drv);void rpmh_tx_done (const struct tcs_request *msg,int r);drivers/soc/qcom/rpmh-rsc.c +17
-0@@ -496,6 +496,26 @@ static int tcs_ctrl_write(struct rsc_drv *drv, const struct tcs_request *msg) }/** +* rpmh_rsc_ctrlr_is_idle: Check if any of the AMCs are busy. +* +* @drv: The controller +* +* Returns true if the TCSes are engaged in handling requests. +*/ +bool rpmh_rsc_ctrlr_is_idle (struct rsc_drv *drv) +{ +int m; +struct tcs_group *tcs =get_tcs_of_type (drv,ACTIVE_TCS ); + +for (m = tcs->offset; m < tcs->offset + tcs->num_tcs; m++) { +if (!tcs_is_free (drv, m)) +return false; + } + +return true;
Quoted 8 lines
drivers/soc/qcom/rpmh-rsc.c static int tcs_ctrl_write(struct rsc_drv *drv, const struct tcs_request *msg) · line 516
Quoted 1 line
drivers/soc/qcom/rpmh-rsc.c +1
-0+}This looks racy,
tcs_write()could be running simultaneously and use TCSes that were seen as free by_is_idle(). This could be fixed by holdingtcs->lock(assuming this doesn't cause lock ordering problems). However even with thistcs_write()could run right after releasing the lock, using TCSes and the caller of_is_idle()would consider the controller to be idle.
We could run this without the lock, since we are only reading a status. Generally, this function is called from the idle code of the last CPU and no CPU or active TCS request should be in progress, but if it were, then this function would let the caller know we are not ready to do idle. If there were no requests that were running at that time we read the registers, we would not be making one after, since we are already in the idle code and no requests are made there.
I understand, how it might appear racy, the context of the callling function helps resolve that.
-- Lina
PATCH v2 2/6 drivers: qcom: rpmh: export controller idle status
In reply to Raju P L S S S NFrom: Lina Iyer <[email protected]>
Allow the controller state be read by platform drivers. This is useful for PM drivers which can choose to disallow idle modes when the controller is busy.
--- drivers/soc/qcom/rpmh.c | 13 +++++++++++++ include/soc/qcom/rpmh.h | 5 +++++ 2 files changed, 18 insertions(+)
drivers/soc/qcom/rpmh.c +13 -0
@@ -511,3 +511,16 @@ int rpmh_invalidate(const struct device *dev)return ret; }EXPORT_SYMBOL (rpmh_invalidate); + +/** +* rpmh_ctrlr_idle: Return the controller idle status +* +* @dev: the device making the request +*/ +int rpmh_ctrlr_idle (const struct device *dev) +{ +struct rpmh_ctrlr *ctrlr =get_rpmh_ctrlr (dev); + +return rpmh_rsc_ctrlr_is_idle (ctrlr_to_drv (ctrlr)); +} +EXPORT_SYMBOL (rpmh_ctrlr_idle);
include/soc/qcom/rpmh.h +5 -0
@@ -24,6 +24,8 @@ int rpmh_write_batch(const struct device *dev, enum rpmh_state state,int rpmh_invalidate (const struct device *dev); +int rpmh_ctrlr_idle (const struct device *dev); +#else static inline int rpmh_write(const struct device *dev, enum rpmh_state state,
@@ -46,6 +48,9 @@ static inline int rpmh_flush(const struct device *dev)static inline int rpmh_invalidate (const struct device *dev) {return -ENODEV ; } +static inline int rpmh_ctrlr_idle (const struct device *dev) +{return -ENODEV ; } +#endif /* CONFIG_QCOM_RPMH */ #endif /* __SOC_QCOM_RPMH_H__ */
Signature · 1 line
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,\na Linux Foundation Collaborative Project
PATCH v2 3/6 drivers: qcom: rpmh: disallow active requests in solver mode
In reply to Raju P L S S S NFrom: Lina Iyer <[email protected]>
Controllers may be in 'solver' state, where they could be in autonomous mode executing low power modes for their hardware and as such are not available for sending active votes. Device driver may notify RPMH API that the controller is in solver mode and when in such mode, disallow requests from platform drivers for state change using the RSC.
--- drivers/soc/qcom/rpmh-internal.h | 2 ++ drivers/soc/qcom/rpmh.c | 59 ++++++++++++++++++++++++++++++++++++++++ include/soc/qcom/rpmh.h | 5 ++++ 3 files changed, 66 insertions(+)
drivers/soc/qcom/rpmh-internal.h +2 -0
@@ -72,12 +72,14 @@ struct rpmh_request {* @cache_lock: synchronize access to the cache data * @dirty: was the cache updated since flush * @batch_cache: Cache sleep and wake requests sent as batch +* @in_solver_mode: Controller is busy in solver mode */ struct rpmh_ctrlr {struct list_head cache;spinlock_t cache_lock;bool dirty;struct list_head batch_cache; +bool in_solver_mode; };/**
drivers/soc/qcom/rpmh.c +59 -0
96 lines not on this page · raw message
include/soc/qcom/rpmh.h +5 -0
@@ -26,6 +26,8 @@ int rpmh_write_batch(const struct device *dev, enum rpmh_state state,int rpmh_ctrlr_idle (const struct device *dev); +int rpmh_mode_solver_set (const struct device *dev,bool enable); +#else static inline int rpmh_write(const struct device *dev, enum rpmh_state state,
@@ -51,6 +53,9 @@ static inline int rpmh_invalidate(const struct device *dev)static inline int rpmh_ctrlr_idle (const struct device *dev) {return -ENODEV ; } +static inline int rpmh_mode_solver_set (const struct device *dev,bool enable) +{return -ENODEV ; } +#endif /* CONFIG_QCOM_RPMH */ #endif /* __SOC_QCOM_RPMH_H__ */
Signature · 1 line
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,\na Linux Foundation Collaborative Project
Re: [PATCH v2 3/6] drivers: qcom: rpmh: disallow active requests in solver mode
Hi Raju/Lina,
Quoted 74 lines · Raju P L S S S N
From: Lina Iyer <[email protected]>
Controllers may be in 'solver' state, where they could be in autonomous mode executing low power modes for their hardware and as such are not available for sending active votes. Device driver may notify RPMH API that the controller is in solver mode and when in such mode, disallow requests from platform drivers for state change using the RSC.
Signed-off-by Lina Iyer <[email protected]>Signed-off-by Raju P.L.S.S.S.N <[email protected]>--- drivers/soc/qcom/rpmh-internal.h | 2 ++ drivers/soc/qcom/rpmh.c | 59 ++++++++++++++++++++++++++++++++++++++++ include/soc/qcom/rpmh.h | 5 ++++ 3 files changed, 66 insertions(+)drivers/soc/qcom/rpmh-internal.h +2
-0@@ -72,12 +72,14 @@ struct rpmh_request {* @cache_lock: synchronize access to the cache data * @dirty: was the cache updated since flush * @batch_cache: Cache sleep and wake requests sent as batch +* @in_solver_mode: Controller is busy in solver mode */ struct rpmh_ctrlr {struct list_head cache;spinlock_t cache_lock;bool dirty;struct list_head batch_cache; +bool in_solver_mode; };/** drivers/soc/qcom/rpmh.c +24
-0@@ -5,6 +5,7 @@#include <linux/atomic.h> #include <linux/bug.h> +#include <linux/delay.h> #include <linux/interrupt.h> #include <linux/jiffies.h> #include <linux/kernel.h> @@ -75,6 +76,50 @@ static struct rpmh_ctrlr *get_rpmh_ctrlr(const struct device *dev)return &drv->client; } +static int check_ctrlr_state (struct rpmh_ctrlr *ctrlr,enum rpmh_state state) +{ +unsigned long flags; +int ret =0 ; + +/* Do not allow setting active votes when in solver mode */ +spin_lock_irqsave (&ctrlr->cache_lock, flags); +if (ctrlr->in_solver_mode && state ==RPMH_ACTIVE_ONLY_STATE ) + ret = -EBUSY ; +spin_unlock_irqrestore (&ctrlr->cache_lock, flags); + +return ret; +} + +/** +* rpmh_mode_solver_set: Indicate that the RSC controller hardware has +* been configured to be in solver mode +* +* @dev: the device making the request +* @enable: Boolean value indicating if the controller is in solver mode. +* +* When solver mode is enabled, passthru API will not be able to send wake +* votes, just awake and active votes.
drivers/soc/qcom/rpmh.c static struct rpmh_ctrlr *get_rpmh_ctrlr(const struct device *dev) · line 111
Quoted 10 lines
drivers/soc/qcom/rpmh.c +10
-0+*/ +int rpmh_mode_solver_set (const struct device *dev,bool enable) +{ +struct rpmh_ctrlr *ctrlr =get_rpmh_ctrlr (dev); +unsigned long flags; + +for (;;) { +spin_lock_irqsave (&ctrlr->cache_lock, flags); +if (rpmh_rsc_ctrlr_is_idle (ctrlr_to_drv (ctrlr))) { + ctrlr->in_solver_mode = enable;
As commented on '[v2,1/6] drivers: qcom: rpmh-rsc: return if the controller is idle', this seems potentially
racy. _is_idle() could report the controller as idle, even though some TCSes are in use (after _is_idle() visited them).
Additional locking may be needed or a comment if this situation should never happen on a sane system (I don't know enough about RPMh and its clients to judge if this is the case).
Re: [PATCH v2 3/6] drivers: qcom: rpmh: disallow active requests in solver mode
Quoted 93 lines · Matthias Kaehlcke
Hi Raju/Lina,
Quoted 74 lines · Raju P L S S S N
From: Lina Iyer <[email protected]>
Controllers may be in 'solver' state, where they could be in autonomous mode executing low power modes for their hardware and as such are not available for sending active votes. Device driver may notify RPMH API that the controller is in solver mode and when in such mode, disallow requests from platform drivers for state change using the RSC.
Signed-off-by Lina Iyer <[email protected]>Signed-off-by Raju P.L.S.S.S.N <[email protected]>--- drivers/soc/qcom/rpmh-internal.h | 2 ++ drivers/soc/qcom/rpmh.c | 59 ++++++++++++++++++++++++++++++++++++++++ include/soc/qcom/rpmh.h | 5 ++++ 3 files changed, 66 insertions(+)drivers/soc/qcom/rpmh-internal.h +2
-0@@ -72,12 +72,14 @@ struct rpmh_request {* @cache_lock: synchronize access to the cache data * @dirty: was the cache updated since flush * @batch_cache: Cache sleep and wake requests sent as batch +* @in_solver_mode: Controller is busy in solver mode */ struct rpmh_ctrlr {struct list_head cache;spinlock_t cache_lock;bool dirty;struct list_head batch_cache; +bool in_solver_mode; };/** drivers/soc/qcom/rpmh.c +24
-0@@ -5,6 +5,7 @@#include <linux/atomic.h> #include <linux/bug.h> +#include <linux/delay.h> #include <linux/interrupt.h> #include <linux/jiffies.h> #include <linux/kernel.h> @@ -75,6 +76,50 @@ static struct rpmh_ctrlr *get_rpmh_ctrlr(const struct device *dev)return &drv->client; } +static int check_ctrlr_state (struct rpmh_ctrlr *ctrlr,enum rpmh_state state) +{ +unsigned long flags; +int ret =0 ; + +/* Do not allow setting active votes when in solver mode */ +spin_lock_irqsave (&ctrlr->cache_lock, flags); +if (ctrlr->in_solver_mode && state ==RPMH_ACTIVE_ONLY_STATE ) + ret = -EBUSY ; +spin_unlock_irqrestore (&ctrlr->cache_lock, flags); + +return ret; +} + +/** +* rpmh_mode_solver_set: Indicate that the RSC controller hardware has +* been configured to be in solver mode +* +* @dev: the device making the request +* @enable: Boolean value indicating if the controller is in solver mode. +* +* When solver mode is enabled, passthru API will not be able to send wake +* votes, just awake and active votes. drivers/soc/qcom/rpmh.c static struct rpmh_ctrlr *get_rpmh_ctrlr(const struct device *dev) · line 111
Quoted 10 lines
drivers/soc/qcom/rpmh.c +10
-0+*/ +int rpmh_mode_solver_set (const struct device *dev,bool enable) +{ +struct rpmh_ctrlr *ctrlr =get_rpmh_ctrlr (dev); +unsigned long flags; + +for (;;) { +spin_lock_irqsave (&ctrlr->cache_lock, flags); +if (rpmh_rsc_ctrlr_is_idle (ctrlr_to_drv (ctrlr))) { + ctrlr->in_solver_mode = enable;As commented on '[v2,1/6] drivers: qcom: rpmh-rsc: return if the controller is idle', this seems potentially
racy._is_idle()could report the controller as idle, even though some TCSes are in use (after_is_idle()visited them).
Quoted 3 lines
Additional locking may be needed or a comment if this situation should never happen on a sane system (I don't know enough about RPMh and its clients to judge if this is the case).
Hmm.. Forgot that we call from here. May be a lock might be helpful.
-- Lina
PATCH v2 4/6 drivers: qcom: rpmh-rsc: clear active mode configuration for waketcs
In reply to Raju P L S S S NFrom: "Raju P.L.S.S.S.N" <[email protected]>
For RSCs that have sleep & wake TCS but no dedicated active TCS, wake TCS can be re-purposed to send active requests. Once the active requests are sent and response is received, the active mode configuration needs to be cleared so that controller can use wake TCS for sending wake requests in 'solver' state while executing low power modes.
--- drivers/soc/qcom/rpmh-rsc.c | 77 +++++++++++++++++++++++++++++++-------------- 1 file changed, 54 insertions(+), 23 deletions(-)
drivers/soc/qcom/rpmh-rsc.c +54 -23
@@ -199,6 +199,42 @@ static const struct tcs_request *get_req_from_tcs(struct rsc_drv *drv,return NULL ; } +static void __tcs_trigger (struct rsc_drv *drv,int tcs_id,bool trigger) +{ +u32 enable; + +/* +* HW req: Clear the DRV_CONTROL and enable TCS again +* While clearing ensure that the AMC mode trigger is cleared +* and then the mode enable is cleared. +*/ + enable =read_tcs_reg (drv,RSC_DRV_CONTROL , tcs_id,0 ); + enable &= ~TCS_AMC_MODE_TRIGGER ; +write_tcs_reg_sync (drv,RSC_DRV_CONTROL , tcs_id, enable); + enable &= ~TCS_AMC_MODE_ENABLE ; +write_tcs_reg_sync (drv,RSC_DRV_CONTROL , tcs_id, enable); + +if (trigger) { +/* Enable the AMC mode on the TCS and then trigger the TCS */ + enable =TCS_AMC_MODE_ENABLE ; +write_tcs_reg_sync (drv,RSC_DRV_CONTROL , tcs_id, enable); + enable |=TCS_AMC_MODE_TRIGGER ; +write_tcs_reg_sync (drv,RSC_DRV_CONTROL , tcs_id, enable); + } +} + +static inline void enable_tcs_irq (struct rsc_drv *drv,int tcs_id,bool enable) +{ +u32 data; + + data =read_tcs_reg (drv,RSC_DRV_IRQ_ENABLE ,0 ,0 ); +if (enable) + data |=BIT (tcs_id); +else + data &= ~BIT (tcs_id); +write_tcs_reg (drv,RSC_DRV_IRQ_ENABLE ,0 , data); +} +/** * tcs_tx_done: TX Done interrupt handler */
@@ -235,6 +271,21 @@ static irqreturn_t tcs_tx_done(int irq, void *p) }trace_rpmh_tx_done (drv, i, req, err); + +/* +* if wake tcs was re-purposed for sending active +* votes, clear AMC trigger & enable modes and +* disable interrupt for this TCS +*/ +if (!drv->tcs[ACTIVE_TCS ].num_tcs) { +__tcs_trigger (drv, i, false); +/* +* Disable interrupt for this TCS to avoid being +* spammed with interrupts coming when the solver +* sends its wake votes. +*/ +enable_tcs_irq (drv, i, false); + } skip:/* Reclaim the TCS */ write_tcs_reg (drv,RSC_DRV_CMD_ENABLE , i,0 );
@@ -282,28 +333,6 @@ static void __tcs_buffer_write(struct rsc_drv *drv, int tcs_id, int cmd_id,write_tcs_reg (drv,RSC_DRV_CMD_ENABLE , tcs_id, cmd_enable); } -static void __tcs_trigger (struct rsc_drv *drv,int tcs_id) -{ -u32 enable; - -/* -* HW req: Clear the DRV_CONTROL and enable TCS again -* While clearing ensure that the AMC mode trigger is cleared -* and then the mode enable is cleared. -*/ - enable =read_tcs_reg (drv,RSC_DRV_CONTROL , tcs_id,0 ); - enable &= ~TCS_AMC_MODE_TRIGGER ; -write_tcs_reg_sync (drv,RSC_DRV_CONTROL , tcs_id, enable); - enable &= ~TCS_AMC_MODE_ENABLE ; -write_tcs_reg_sync (drv,RSC_DRV_CONTROL , tcs_id, enable); - -/* Enable the AMC mode on the TCS and then trigger the TCS */ - enable =TCS_AMC_MODE_ENABLE ; -write_tcs_reg_sync (drv,RSC_DRV_CONTROL , tcs_id, enable); - enable |=TCS_AMC_MODE_TRIGGER ; -write_tcs_reg_sync (drv,RSC_DRV_CONTROL , tcs_id, enable); -} -static int check_for_req_inflight (struct rsc_drv *drv,struct tcs_group *tcs,const struct tcs_request *msg) {
@@ -374,10 +403,12 @@ static int tcs_write(struct rsc_drv *drv, const struct tcs_request *msg) tcs->req[tcs_id - tcs->offset] = msg;set_bit (tcs_id, drv->tcs_in_use); +if (msg->state ==RPMH_ACTIVE_ONLY_STATE && tcs->type !=ACTIVE_TCS ) +enable_tcs_irq (drv, tcs_id, true);spin_unlock (&drv->lock);__tcs_buffer_write (drv, tcs_id,0 , msg); -__tcs_trigger (drv, tcs_id); +__tcs_trigger (drv, tcs_id, true); done_write:spin_unlock_irqrestore (&tcs->lock, flags);
Signature · 1 line
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,\na Linux Foundation Collaborative Project
Re: [PATCH v2 4/6] drivers: qcom: rpmh-rsc: clear active mode configuration for waketcs
Quoted 112 lines · Raju P L S S S N
From: "Raju P.L.S.S.S.N" <[email protected]>
For RSCs that have sleep & wake TCS but no dedicated active TCS, wake TCS can be re-purposed to send active requests. Once the active requests are sent and response is received, the active mode configuration needs to be cleared so that controller can use wake TCS for sending wake requests in 'solver' state while executing low power modes.
Signed-off-by Raju P.L.S.S.S.N <[email protected]>--- drivers/soc/qcom/rpmh-rsc.c | 77 +++++++++++++++++++++++++++++++-------------- 1 file changed, 54 insertions(+), 23 deletions(-)drivers/soc/qcom/rpmh-rsc.c +51
-22@@ -199,6 +199,42 @@ static const struct tcs_request *get_req_from_tcs(struct rsc_drv *drv,return NULL ; } +static void __tcs_trigger (struct rsc_drv *drv,int tcs_id,bool trigger) +{ +u32 enable; + +/* +* HW req: Clear the DRV_CONTROL and enable TCS again +* While clearing ensure that the AMC mode trigger is cleared +* and then the mode enable is cleared. +*/ + enable =read_tcs_reg (drv,RSC_DRV_CONTROL , tcs_id,0 ); + enable &= ~TCS_AMC_MODE_TRIGGER ; +write_tcs_reg_sync (drv,RSC_DRV_CONTROL , tcs_id, enable); + enable &= ~TCS_AMC_MODE_ENABLE ; +write_tcs_reg_sync (drv,RSC_DRV_CONTROL , tcs_id, enable); + +if (trigger) { +/* Enable the AMC mode on the TCS and then trigger the TCS */ + enable =TCS_AMC_MODE_ENABLE ; +write_tcs_reg_sync (drv,RSC_DRV_CONTROL , tcs_id, enable); + enable |=TCS_AMC_MODE_TRIGGER ; +write_tcs_reg_sync (drv,RSC_DRV_CONTROL , tcs_id, enable); + } +} + +static inline void enable_tcs_irq (struct rsc_drv *drv,int tcs_id,bool enable) +{ +u32 data; + + data =read_tcs_reg (drv,RSC_DRV_IRQ_ENABLE ,0 ,0 ); +if (enable) + data |=BIT (tcs_id); +else + data &= ~BIT (tcs_id); +write_tcs_reg (drv,RSC_DRV_IRQ_ENABLE ,0 , data); +} +/** * tcs_tx_done: TX Done interrupt handler */ @@ -235,6 +271,21 @@ static irqreturn_t tcs_tx_done(int irq, void *p) }trace_rpmh_tx_done (drv, i, req, err); + +/* +* if wake tcs was re-purposed for sending active +* votes, clear AMC trigger & enable modes and +* disable interrupt for this TCS +*/ +if (!drv->tcs[ACTIVE_TCS ].num_tcs) { +__tcs_trigger (drv, i, false); +/* +* Disable interrupt for this TCS to avoid being +* spammed with interrupts coming when the solver +* sends its wake votes. +*/ +enable_tcs_irq (drv, i, false); + } skip:/* Reclaim the TCS */ write_tcs_reg (drv,RSC_DRV_CMD_ENABLE , i,0 );@@ -282,28 +333,6 @@ static void __tcs_buffer_write(struct rsc_drv *drv, int tcs_id, int cmd_id,write_tcs_reg (drv,RSC_DRV_CMD_ENABLE , tcs_id, cmd_enable); } -static void __tcs_trigger (struct rsc_drv *drv,int tcs_id) -{ -u32 enable; - -/* -* HW req: Clear the DRV_CONTROL and enable TCS again -* While clearing ensure that the AMC mode trigger is cleared -* and then the mode enable is cleared. -*/ - enable =read_tcs_reg (drv,RSC_DRV_CONTROL , tcs_id,0 ); - enable &= ~TCS_AMC_MODE_TRIGGER ; -write_tcs_reg_sync (drv,RSC_DRV_CONTROL , tcs_id, enable); - enable &= ~TCS_AMC_MODE_ENABLE ; -write_tcs_reg_sync (drv,RSC_DRV_CONTROL , tcs_id, enable); - -/* Enable the AMC mode on the TCS and then trigger the TCS */ - enable =TCS_AMC_MODE_ENABLE ; -write_tcs_reg_sync (drv,RSC_DRV_CONTROL , tcs_id, enable); - enable |=TCS_AMC_MODE_TRIGGER ; -write_tcs_reg_sync (drv,RSC_DRV_CONTROL , tcs_id, enable); -} -static int check_for_req_inflight (struct rsc_drv *drv,struct tcs_group *tcs,const struct tcs_request *msg) {
drivers/soc/qcom/rpmh-rsc.c static int tcs_write(struct rsc_drv *drv, const struct tcs_request *msg) · line 407
Quoted 5 lines
drivers/soc/qcom/rpmh-rsc.c +2
-0@@ -374,10 +403,12 @@ static int tcs_write(struct rsc_drv *drv, const struct tcs_request *msg) tcs->req[tcs_id - tcs->offset] = msg;set_bit (tcs_id, drv->tcs_in_use); +if (msg->state ==RPMH_ACTIVE_ONLY_STATE && tcs->type !=ACTIVE_TCS ) +enable_tcs_irq (drv, tcs_id, true);
You might want to add a short comment here. In the context of this patch it is (relatively) clear that the wake TCS is re-purposed for active requests, and the interrupt is disabled by default for non-active TCSes. However on it's own this isn't necessarily evident without looking through the code.
drivers/soc/qcom/rpmh-rsc.c static int tcs_write(struct rsc_drv *drv, const struct tcs_request *msg) · line 414
Quoted 8 lines
drivers/soc/qcom/rpmh-rsc.c +1
-1spin_unlock (&drv->lock);__tcs_buffer_write (drv, tcs_id,0 , msg); -__tcs_trigger (drv, tcs_id); +__tcs_trigger (drv, tcs_id, true); done_write:spin_unlock_irqrestore (&tcs->lock, flags);
PATCH v2 5/6 drivers: qcom: rpmh-rsc: write PDC data
In reply to Raju P L S S S NFrom: Lina Iyer <[email protected]>
The Power Domain Controller can be programmed to wakeup the RSC and setup the resources back in the active state, before the processor is woken up by a timer interrupt. The wakeup value from the timer hardware can be copied to the PDC which has its own timer and is in an always-on power domain. Programming the wakeup value is done through a separate register on the RSC.
---
Changes in v2:
- Remove unnecessary EXPORT_SYMBOL
--- drivers/soc/qcom/rpmh-internal.h | 3 +++ drivers/soc/qcom/rpmh-rsc.c | 35 +++++++++++++++++++++++++++++------ 2 files changed, 32 insertions(+), 6 deletions(-)
drivers/soc/qcom/rpmh-internal.h +3 -0
@@ -87,6 +87,7 @@ struct rpmh_ctrlr {* Resource State Coordinator controller (RSC) * * @name: controller identifier +* @base: start address of the RSC's DRV registers * @tcs_base: start address of the TCS registers in this controller * @id: instance id in the controller (Direct Resource Voter) * @num_tcs: number of TCSes in this DRV
@@ -97,6 +98,7 @@ struct rpmh_ctrlr {*/ struct rsc_drv {const char *name; +void __iomem *base;void __iomem *tcs_base;int id;int num_tcs;
@@ -111,6 +113,7 @@ int rpmh_rsc_write_ctrl_data(struct rsc_drv *drv, const struct tcs_request *msg);int rpmh_rsc_invalidate (struct rsc_drv *drv);bool rpmh_rsc_ctrlr_is_idle (struct rsc_drv *drv); +int rpmh_rsc_write_pdc_data (struct rsc_drv *drv,const struct tcs_request *msg);void rpmh_tx_done (const struct tcs_request *msg,int r);
drivers/soc/qcom/rpmh-rsc.c +29 -6
@@ -60,6 +60,11 @@#define CMD_STATUS_ISSUED BIT(8)#define CMD_STATUS_COMPL BIT(16) +/* PDC wakeup */ +#define RSC_PDC_DATA_SIZE 2 +#define RSC_PDC_DRV_DATA 0x38 +#define RSC_PDC_DATA_OFFSET 0x08 +static u32 read_tcs_reg (struct rsc_drv *drv,int reg,int tcs_id,int cmd_id) { return readl_relaxed(drv->tcs_base + reg + RSC_DRV_TCS_OFFSET * tcs_id +
@@ -569,6 +574,25 @@ int rpmh_rsc_write_ctrl_data(struct rsc_drv *drv, const struct tcs_request *msg)return tcs_ctrl_write (drv, msg); } +int rpmh_rsc_write_pdc_data (struct rsc_drv *drv,const struct tcs_request *msg) +{ +int i; +void __iomem *addr = drv->base +RSC_PDC_DRV_DATA ; + +if (!msg || !msg->cmds || msg->num_cmds !=RSC_PDC_DATA_SIZE ) +return -EINVAL ; + +for (i =0 ; i < msg->num_cmds; i++) { +/* Only data is write capable */ +writel_relaxed (msg->cmds[i].data, addr); +trace_rpmh_send_msg (drv,RSC_PDC_DRV_DATA , i,0 , + &msg->cmds[i]); + addr +=RSC_PDC_DATA_OFFSET ; + } + +return 0 ; +} +static int rpmh_probe_tcs_config (struct platform_device *pdev,struct rsc_drv *drv) {
@@ -581,21 +605,20 @@ static int rpmh_probe_tcs_config(struct platform_device *pdev,int i, ret, n, st =0 ;struct tcs_group *tcs;struct resource *res; -void __iomem *base;char drv_id[10 ] = {0 };snprintf (drv_id,ARRAY_SIZE (drv_id),"drv-%d" , drv->id); res =platform_get_resource_byname (pdev,IORESOURCE_MEM , drv_id); - base =devm_ioremap_resource (&pdev->dev, res); -if (IS_ERR (base)) -return PTR_ERR (base); + drv->base =devm_ioremap_resource (&pdev->dev, res); +if (IS_ERR (drv->base)) +return PTR_ERR (drv->base); ret =of_property_read_u32 (dn,"qcom,tcs-offset" , &offset);if (ret)return ret; - drv->tcs_base = base + offset; + drv->tcs_base = drv->base + offset; - config =readl_relaxed (base +DRV_PRNT_CHLD_CONFIG ); + config =readl_relaxed (drv->base +DRV_PRNT_CHLD_CONFIG ); max_tcs = config; max_tcs &=DRV_NUM_TCS_MASK << (DRV_NUM_TCS_SHIFT * drv->id);
Signature · 1 line
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,\na Linux Foundation Collaborative Project
Re: [PATCH v2 5/6] drivers: qcom: rpmh-rsc: write PDC data
Quoted 64 lines · Raju P L S S S N
From: Lina Iyer <[email protected]>
The Power Domain Controller can be programmed to wakeup the RSC and setup the resources back in the active state, before the processor is woken up by a timer interrupt. The wakeup value from the timer hardware can be copied to the PDC which has its own timer and is in an always-on power domain. Programming the wakeup value is done through a separate register on the RSC.
Signed-off-by Lina Iyer <[email protected]>Signed-off-by Raju P.L.S.S.S.N <[email protected]>---
Changes in v2:
- Remove unnecessaryEXPORT_SYMBOL--- drivers/soc/qcom/rpmh-internal.h | 3 +++ drivers/soc/qcom/rpmh-rsc.c | 35 +++++++++++++++++++++++++++++------ 2 files changed, 32 insertions(+), 6 deletions(-)drivers/soc/qcom/rpmh-internal.h +3
-0@@ -87,6 +87,7 @@ struct rpmh_ctrlr {* Resource State Coordinator controller (RSC) * * @name: controller identifier +* @base: start address of the RSC's DRV registers * @tcs_base: start address of the TCS registers in this controller * @id: instance id in the controller (Direct Resource Voter) * @num_tcs: number of TCSes in this DRV @@ -97,6 +98,7 @@ struct rpmh_ctrlr {*/ struct rsc_drv {const char *name; +void __iomem *base;void __iomem *tcs_base;int id;int num_tcs;@@ -111,6 +113,7 @@ int rpmh_rsc_write_ctrl_data(struct rsc_drv *drv, const struct tcs_request *msg);int rpmh_rsc_invalidate (struct rsc_drv *drv);bool rpmh_rsc_ctrlr_is_idle (struct rsc_drv *drv); +int rpmh_rsc_write_pdc_data (struct rsc_drv *drv,const struct tcs_request *msg);void rpmh_tx_done (const struct tcs_request *msg,int r);drivers/soc/qcom/rpmh-rsc.c +5
-0@@ -60,6 +60,11 @@#define CMD_STATUS_ISSUED BIT(8)#define CMD_STATUS_COMPL BIT(16) +/* PDC wakeup */ +#define RSC_PDC_DATA_SIZE 2 +#define RSC_PDC_DRV_DATA 0x38 +#define RSC_PDC_DATA_OFFSET 0x08 +static u32 read_tcs_reg (struct rsc_drv *drv,int reg,int tcs_id,int cmd_id) { return readl_relaxed(drv->tcs_base + reg + RSC_DRV_TCS_OFFSET * tcs_id +
drivers/soc/qcom/rpmh-rsc.c int rpmh_rsc_write_ctrl_data(struct rsc_drv *drv, const struct tcs_request *msg) · line 583
Quoted 10 lines
drivers/soc/qcom/rpmh-rsc.c +7
-0@@ -569,6 +574,25 @@ int rpmh_rsc_write_ctrl_data(struct rsc_drv *drv, const struct tcs_request *msg)return tcs_ctrl_write (drv, msg); } +int rpmh_rsc_write_pdc_data (struct rsc_drv *drv,const struct tcs_request *msg) +{ +int i; +void __iomem *addr = drv->base +RSC_PDC_DRV_DATA ; + +if (!msg || !msg->cmds || msg->num_cmds !=RSC_PDC_DATA_SIZE ) +return -EINVAL ;
Is it really always exactly 2 (RSC_PDC_DATA_SIZE) commands?
Quoted 42 lines
drivers/soc/qcom/rpmh-rsc.c +17
-6+ +for (i =0 ; i < msg->num_cmds; i++) { +/* Only data is write capable */ +writel_relaxed (msg->cmds[i].data, addr); +trace_rpmh_send_msg (drv,RSC_PDC_DRV_DATA , i,0 , + &msg->cmds[i]); + addr +=RSC_PDC_DATA_OFFSET ; + } + +return 0 ; +} +static int rpmh_probe_tcs_config (struct platform_device *pdev,struct rsc_drv *drv) {@@ -581,21 +605,20 @@ static int rpmh_probe_tcs_config(struct platform_device *pdev,int i, ret, n, st =0 ;struct tcs_group *tcs;struct resource *res; -void __iomem *base;char drv_id[10 ] = {0 };snprintf (drv_id,ARRAY_SIZE (drv_id),"drv-%d" , drv->id); res =platform_get_resource_byname (pdev,IORESOURCE_MEM , drv_id); - base =devm_ioremap_resource (&pdev->dev, res); -if (IS_ERR (base)) -return PTR_ERR (base); + drv->base =devm_ioremap_resource (&pdev->dev, res); +if (IS_ERR (drv->base)) +return PTR_ERR (drv->base); ret =of_property_read_u32 (dn,"qcom,tcs-offset" , &offset);if (ret)return ret; - drv->tcs_base = base + offset; + drv->tcs_base = drv->base + offset; - config =readl_relaxed (base +DRV_PRNT_CHLD_CONFIG ); + config =readl_relaxed (drv->base +DRV_PRNT_CHLD_CONFIG ); max_tcs = config; max_tcs &=DRV_NUM_TCS_MASK << (DRV_NUM_TCS_SHIFT * drv->id);
Re: [PATCH v2 5/6] drivers: qcom: rpmh-rsc: write PDC data
Quoted 17 lines · Matthias Kaehlcke
Quoted 15 lines · Raju P L S S S N
From: Lina Iyer <[email protected]>
The Power Domain Controller can be programmed to wakeup the RSC and setup the resources back in the active state, before the processor is woken up by a timer interrupt. The wakeup value from the timer hardware can be copied to the PDC which has its own timer and is in an always-on power domain. Programming the wakeup value is done through a separate register on the RSC.
Signed-off-by Lina Iyer <[email protected]>Signed-off-by Raju P.L.S.S.S.N <[email protected]>---
Changes in v2:
- Remove unnecessaryEXPORT_SYMBOL
---
Quoted 10 lines
drivers/soc/qcom/rpmh-rsc.c int rpmh_rsc_write_ctrl_data(struct rsc_drv *drv, const struct tcs_request *msg) · line 583
Quoted 7 lines
drivers/soc/qcom/rpmh-rsc.c +7
-0+int rpmh_rsc_write_pdc_data (struct rsc_drv *drv,const struct tcs_request *msg) +{ +int i; +void __iomem *addr = drv->base +RSC_PDC_DRV_DATA ; + +if (!msg || !msg->cmds || msg->num_cmds !=RSC_PDC_DATA_SIZE ) +return -EINVAL ;Is it really always exactly 2 (
RSC_PDC_DATA_SIZE) commands?
Yes, always.
Matthias Kaehlcke
Reviewed-byRe: [PATCH v2 5/6] drivers: qcom: rpmh-rsc: write PDC data
Quoted 28 lines · Lina Iyer
Quoted 17 lines · Matthias Kaehlcke
Quoted 15 lines · Raju P L S S S N
From: Lina Iyer <[email protected]>
The Power Domain Controller can be programmed to wakeup the RSC and setup the resources back in the active state, before the processor is woken up by a timer interrupt. The wakeup value from the timer hardware can be copied to the PDC which has its own timer and is in an always-on power domain. Programming the wakeup value is done through a separate register on the RSC.
Signed-off-by Lina Iyer <[email protected]>Signed-off-by Raju P.L.S.S.S.N <[email protected]>---
Changes in v2:
- Remove unnecessaryEXPORT_SYMBOL
---Quoted 10 lines
drivers/soc/qcom/rpmh-rsc.c int rpmh_rsc_write_ctrl_data(struct rsc_drv *drv, const struct tcs_request *msg) · line 583
Quoted 7 lines
drivers/soc/qcom/rpmh-rsc.c +7
-0+int rpmh_rsc_write_pdc_data (struct rsc_drv *drv,const struct tcs_request *msg) +{ +int i; +void __iomem *addr = drv->base +RSC_PDC_DRV_DATA ; + +if (!msg || !msg->cmds || msg->num_cmds !=RSC_PDC_DATA_SIZE ) +return -EINVAL ;Is it really always exactly 2 (
RSC_PDC_DATA_SIZE) commands?
Quoted 1 line
Yes, always.
Thanks for the confirmation!
PATCH v2 6/6 drivers: qcom: rpmh: write PDC data
In reply to Raju P L S S S NFrom: Lina Iyer <[email protected]>
In addition to requests that are send to the remote processor, the controller may allow certain data to be written to the controller for use in specific cases like wakeup value when entering idle states. Allow a pass through to write PDC data.
--- drivers/soc/qcom/rpmh.c | 28 ++++++++++++++++++++++++++++ include/soc/qcom/rpmh.h | 6 ++++++ 2 files changed, 34 insertions(+)
drivers/soc/qcom/rpmh.c +28 -0
@@ -472,6 +472,34 @@ int rpmh_write_batch(const struct device *dev, enum rpmh_state state, }EXPORT_SYMBOL (rpmh_write_batch); +/** +* rpmh_write_pdc_data: Write PDC data to the controller +* +* @dev: the device making the request +* @cmd: The payload data +* @n: The number of elements in payload +* +* Write PDC data to the controller. The messages are always sent async. +* +* May be called from atomic contexts. +*/ +int rpmh_write_pdc_data (const struct device *dev, +const struct tcs_cmd *cmd,u32 n) +{ +DEFINE_RPMH_MSG_ONSTACK (dev,0 ,NULL , rpm_msg); +struct rpmh_ctrlr *ctrlr =get_rpmh_ctrlr (dev); + +if (!n || n >MAX_RPMH_PAYLOAD ) +return -EINVAL ; + +memcpy (rpm_msg.cmd, cmd, n *sizeof (*cmd)); + rpm_msg.msg.num_cmds = n; + rpm_msg.msg.wait_for_compl = false; + +return rpmh_rsc_write_pdc_data (ctrlr_to_drv (ctrlr), &rpm_msg.msg); +} +EXPORT_SYMBOL (rpmh_write_pdc_data); +static int is_req_valid (struct cache_req *req) { return (req->sleep_val != UINT_MAX &&
include/soc/qcom/rpmh.h +6 -0
@@ -28,6 +28,9 @@ int rpmh_write_batch(const struct device *dev, enum rpmh_state state,int rpmh_mode_solver_set (const struct device *dev,bool enable); +int rpmh_write_pdc_data (const struct device *dev, +const struct tcs_cmd *cmd,u32 n); +#else static inline int rpmh_write(const struct device *dev, enum rpmh_state state,
@@ -56,6 +59,9 @@ static inline int rpmh_ctrlr_idle(const struct device *dev)static inline int rpmh_mode_solver_set (const struct device *dev,bool enable) {return -ENODEV ; } +static inline int rpmh_write_pdc_data (const struct device *dev, +const struct tcs_cmd *cmd,u32 n) +{return -ENODEV ; }#endif /* CONFIG_QCOM_RPMH */ #endif /* __SOC_QCOM_RPMH_H__ */
Signature · 1 line
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,\na Linux Foundation Collaborative Project
Re: [PATCH v2 6/6] drivers: qcom: rpmh: write PDC data
Quoted 27 lines · Raju P L S S S N
From: Lina Iyer <[email protected]>
In addition to requests that are send to the remote processor, the controller may allow certain data to be written to the controller for use in specific cases like wakeup value when entering idle states. Allow a pass through to write PDC data.
Signed-off-by Lina Iyer <[email protected]>Signed-off-by Raju P.L.S.S.S.N <[email protected]>--- drivers/soc/qcom/rpmh.c | 28 ++++++++++++++++++++++++++++ include/soc/qcom/rpmh.h | 6 ++++++ 2 files changed, 34 insertions(+)drivers/soc/qcom/rpmh.c +5
-0@@ -472,6 +472,34 @@ int rpmh_write_batch(const struct device *dev, enum rpmh_state state, }EXPORT_SYMBOL (rpmh_write_batch); +/** +* rpmh_write_pdc_data: Write PDC data to the controller +* +* @dev: the device making the request +* @cmd: The payload data
drivers/soc/qcom/rpmh.c int rpmh_write_batch(const struct device *dev, enum rpmh_state state, · line 489
Quoted 10 lines
drivers/soc/qcom/rpmh.c +10
-0+* @n: The number of elements in payload +* +* Write PDC data to the controller. The messages are always sent async. +* +* May be called from atomic contexts. +*/ +int rpmh_write_pdc_data (const struct device *dev, +const struct tcs_cmd *cmd,u32 n) +{ +DEFINE_RPMH_MSG_ONSTACK (dev,0 ,NULL , rpm_msg);
At first I was concerned about the message being created on the stack and sent asynchronously, however there is no asynchronous access to the on-stack memory after returning from rpmh_rsc_write_pdc_data().
Quoted 31 lines
drivers/soc/qcom/rpmh.c +13
-0+struct rpmh_ctrlr *ctrlr =get_rpmh_ctrlr (dev); + +if (!n || n >MAX_RPMH_PAYLOAD ) +return -EINVAL ; + +memcpy (rpm_msg.cmd, cmd, n *sizeof (*cmd)); + rpm_msg.msg.num_cmds = n; + rpm_msg.msg.wait_for_compl = false; + +return rpmh_rsc_write_pdc_data (ctrlr_to_drv (ctrlr), &rpm_msg.msg); +} +EXPORT_SYMBOL (rpmh_write_pdc_data); +static int is_req_valid (struct cache_req *req) { return (req->sleep_val != UINT_MAX &&include/soc/qcom/rpmh.h +3
-0@@ -28,6 +28,9 @@ int rpmh_write_batch(const struct device *dev, enum rpmh_state state,int rpmh_mode_solver_set (const struct device *dev,bool enable); +int rpmh_write_pdc_data (const struct device *dev, +const struct tcs_cmd *cmd,u32 n); +#else static inline int rpmh_write(const struct device *dev, enum rpmh_state state,
include/soc/qcom/rpmh.h static inline int rpmh_ctrlr_idle(const struct device *dev) · line 67
Quoted 9 lines
include/soc/qcom/rpmh.h +3
-0@@ -56,6 +59,9 @@ static inline int rpmh_ctrlr_idle(const struct device *dev)static inline int rpmh_mode_solver_set (const struct device *dev,bool enable) {return -ENODEV ; } +static inline int rpmh_write_pdc_data (const struct device *dev, +const struct tcs_cmd *cmd,u32 n) +{return -ENODEV ; }#endif /* CONFIG_QCOM_RPMH */ #endif /* __SOC_QCOM_RPMH_H__ */
Stephen, Doug,
Would you have some time to take a look at this series?
Thanks,
Lina
Quoted 52 lines · Raju P L S S S N
From: "Raju P.L.S.S.S.N" <[email protected]>
Changes in v1:
- Remove unnecessaryEXPORT_SYMBOLin rpmh-rscThis set of patches add additional functionality to RPMH drivers[1].
PM drivers can choose to disallow idle modes when RSC controller is busy sending or processing requests. The patches add necessary functions to query the controller status.
The controllers may be in 'solver' state, where they could be in autonomous mode executing low power modes for their hardware and as such are not available for sending active votes. Functionality to get notified about such state and disallow requests for state change in that case is added in these patches.
The Power Domain Controller can be programmed to wakeup the RSC and setup the resources back in the active state, before the processor is woken up by a timer interrupt. The wakeup value from the timer hardware can be copied to the PDC which has its own timer and is in an always-on power domain. Programming the wakeup value is done through a separate register on the RSC. Functions necessary to program wakeup is added in the patches.
Please consider reviewing this patchset.
v1:https://lkml.org/lkml/2018/7/19/213
[1] https://lkml.org/lkml/2018/6/20/519
Lina Iyer (5):
drivers: qcom: rpmh-rsc: return if the controller is idle
drivers: qcom: rpmh: export controller idle status
drivers: qcom: rpmh: disallow active requests in solver mode
drivers: qcom: rpmh-rsc: write PDC data
drivers: qcom: rpmh: write PDC dataRaju P.L.S.S.S.N (1):
drivers: qcom: rpmh-rsc: clear active mode configuration for waketcsdrivers/soc/qcom/rpmh-internal.h | 6 ++ drivers/soc/qcom/rpmh-rsc.c | 132 ++++++++++++++++++++++++++++++--------- drivers/soc/qcom/rpmh.c | 100 +++++++++++++++++++++++++++++ include/soc/qcom/rpmh.h | 16 +++++ 4 files changed, 225 insertions(+), 29 deletions(-)--
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,\na Linux Foundation Collaborative Project