drivers/i2c/busses/i2c-designware-amdpsp.c | 68 +++++++++++++++++----- 1 file changed, 53 insertions(+), 15 deletions(-)
In order to optimize performance, limit amount of back and forth
transactions between x86 and PSP. This is done by introduction of
cooldown period - that is window in which x86 isn't releasing the bus
immediately after each I2C transaction.
In order to protect PSP from being starved while waiting for
arbitration, after a programmed time bus is automatically released by a
deferred function.
Signed-off-by: Jan Dabros <jsd@semihalf.com>
---
drivers/i2c/busses/i2c-designware-amdpsp.c | 68 +++++++++++++++++-----
1 file changed, 53 insertions(+), 15 deletions(-)
diff --git a/drivers/i2c/busses/i2c-designware-amdpsp.c b/drivers/i2c/busses/i2c-designware-amdpsp.c
index b624356c945f..2e1bb5ae72c3 100644
--- a/drivers/i2c/busses/i2c-designware-amdpsp.c
+++ b/drivers/i2c/busses/i2c-designware-amdpsp.c
@@ -6,6 +6,7 @@
#include <linux/io-64-nonatomic-lo-hi.h>
#include <linux/psp-sev.h>
#include <linux/types.h>
+#include <linux/workqueue.h>
#include <asm/msr.h>
@@ -15,6 +16,8 @@
#define PSP_MBOX_OFFSET 0x10570
#define PSP_CMD_TIMEOUT_US (500 * USEC_PER_MSEC)
+#define PSP_I2C_COOLDOWN_TIME_MS 100
+
#define PSP_I2C_REQ_BUS_CMD 0x64
#define PSP_I2C_REQ_RETRY_CNT 400
#define PSP_I2C_REQ_RETRY_DELAY_US (25 * USEC_PER_MSEC)
@@ -240,6 +243,42 @@ static int psp_send_i2c_req(enum psp_i2c_req_type i2c_req_type)
return ret;
}
+static void release_bus_now(void)
+{
+ int status;
+
+ if (!psp_i2c_sem_acquired)
+ return;
+
+ status = psp_send_i2c_req(PSP_I2C_REQ_RELEASE);
+ if (status)
+ return;
+
+ dev_dbg(psp_i2c_dev, "PSP semaphore held for %ums\n",
+ jiffies_to_msecs(jiffies - psp_i2c_sem_acquired));
+
+ psp_i2c_sem_acquired = 0;
+}
+
+static void psp_release_i2c_bus_deferred(struct work_struct *work)
+{
+
+ mutex_lock(&psp_i2c_access_mutex);
+
+ /*
+ * If there is any pending transaction, cannot release the bus here.
+ * psp_release_i2c_bus will take care of this later.
+ */
+ if (psp_i2c_access_count)
+ goto cleanup;
+
+ release_bus_now();
+
+cleanup:
+ mutex_unlock(&psp_i2c_access_mutex);
+}
+static DECLARE_DELAYED_WORK(release_queue, psp_release_i2c_bus_deferred);
+
static int psp_acquire_i2c_bus(void)
{
int status;
@@ -250,21 +289,23 @@ static int psp_acquire_i2c_bus(void)
if (psp_i2c_mbox_fail)
goto cleanup;
+ psp_i2c_access_count++;
+
/*
- * Simply increment usage counter and return if PSP semaphore was
- * already taken by kernel.
+ * No need to request bus arbitration once we are inside cooldown
+ * period.
*/
- if (psp_i2c_access_count) {
- psp_i2c_access_count++;
+ if (psp_i2c_sem_acquired)
goto cleanup;
- }
status = psp_send_i2c_req(PSP_I2C_REQ_ACQUIRE);
if (status)
goto cleanup;
psp_i2c_sem_acquired = jiffies;
- psp_i2c_access_count++;
+
+ schedule_delayed_work(&release_queue,
+ msecs_to_jiffies(PSP_I2C_COOLDOWN_TIME_MS));
/*
* In case of errors with PSP arbitrator psp_i2c_mbox_fail variable is
@@ -279,8 +320,6 @@ static int psp_acquire_i2c_bus(void)
static void psp_release_i2c_bus(void)
{
- int status;
-
mutex_lock(&psp_i2c_access_mutex);
/* Return early if mailbox was malfunctional */
@@ -295,13 +334,12 @@ static void psp_release_i2c_bus(void)
if (psp_i2c_access_count)
goto cleanup;
- /* Send a release command to PSP */
- status = psp_send_i2c_req(PSP_I2C_REQ_RELEASE);
- if (status)
- goto cleanup;
-
- dev_dbg(psp_i2c_dev, "PSP semaphore held for %ums\n",
- jiffies_to_msecs(jiffies - psp_i2c_sem_acquired));
+ /*
+ * Send a release command to PSP if the cooldown timeout elapsed but x86 still
+ * owns the ctrlr.
+ */
+ if (!delayed_work_pending(&release_queue))
+ release_bus_now();
cleanup:
mutex_unlock(&psp_i2c_access_mutex);
--
2.37.1.359.gd136c6c3e2-googHi Sorry the delay, this slipped through my eyes during vacation. Couple minor comments below. On 7/25/22 11:02, Jan Dabros wrote: > In order to optimize performance, limit amount of back and forth > transactions between x86 and PSP. This is done by introduction of > cooldown period - that is window in which x86 isn't releasing the bus > immediately after each I2C transaction. > > In order to protect PSP from being starved while waiting for > arbitration, after a programmed time bus is automatically released by a > deferred function. > > Signed-off-by: Jan Dabros <jsd@semihalf.com> > --- > drivers/i2c/busses/i2c-designware-amdpsp.c | 68 +++++++++++++++++----- > 1 file changed, 53 insertions(+), 15 deletions(-) > > diff --git a/drivers/i2c/busses/i2c-designware-amdpsp.c b/drivers/i2c/busses/i2c-designware-amdpsp.c > index b624356c945f..2e1bb5ae72c3 100644 > --- a/drivers/i2c/busses/i2c-designware-amdpsp.c > +++ b/drivers/i2c/busses/i2c-designware-amdpsp.c > @@ -6,6 +6,7 @@ > #include <linux/io-64-nonatomic-lo-hi.h> > #include <linux/psp-sev.h> > #include <linux/types.h> > +#include <linux/workqueue.h> > > #include <asm/msr.h> > > @@ -15,6 +16,8 @@ > #define PSP_MBOX_OFFSET 0x10570 > #define PSP_CMD_TIMEOUT_US (500 * USEC_PER_MSEC) > > +#define PSP_I2C_COOLDOWN_TIME_MS 100 > + "cooldown" distract me thinking thermal management. Would semaphore reservation time/timer fit better? > +static void release_bus_now(void) > +static void psp_release_i2c_bus_deferred(struct work_struct *work) > +static DECLARE_DELAYED_WORK(release_queue, psp_release_i2c_bus_deferred); > + I'd use the same namespace here. Perhaps _now can be dropped from the name since the release_bus and release_bus_deferred are near to each other and _deferred variant implies it's called after timeout. > + /* > + * Send a release command to PSP if the cooldown timeout elapsed but x86 still > + * owns the ctrlr. > + */ Replace "ctrlr" -> "control" here since then it doesn't lead to think is't some technical object like register etc.
wt., 9 sie 2022 o 14:05 Jarkko Nikula <jarkko.nikula@linux.intel.com> napisał(a): > > Hi > > Sorry the delay, this slipped through my eyes during vacation. Couple > minor comments below. > > On 7/25/22 11:02, Jan Dabros wrote: > > In order to optimize performance, limit amount of back and forth > > transactions between x86 and PSP. This is done by introduction of > > cooldown period - that is window in which x86 isn't releasing the bus > > immediately after each I2C transaction. > > > > In order to protect PSP from being starved while waiting for > > arbitration, after a programmed time bus is automatically released by a > > deferred function. > > > > Signed-off-by: Jan Dabros <jsd@semihalf.com> > > --- > > drivers/i2c/busses/i2c-designware-amdpsp.c | 68 +++++++++++++++++----- > > 1 file changed, 53 insertions(+), 15 deletions(-) > > > > diff --git a/drivers/i2c/busses/i2c-designware-amdpsp.c b/drivers/i2c/busses/i2c-designware-amdpsp.c > > index b624356c945f..2e1bb5ae72c3 100644 > > --- a/drivers/i2c/busses/i2c-designware-amdpsp.c > > +++ b/drivers/i2c/busses/i2c-designware-amdpsp.c > > @@ -6,6 +6,7 @@ > > #include <linux/io-64-nonatomic-lo-hi.h> > > #include <linux/psp-sev.h> > > #include <linux/types.h> > > +#include <linux/workqueue.h> > > > > #include <asm/msr.h> > > > > @@ -15,6 +16,8 @@ > > #define PSP_MBOX_OFFSET 0x10570 > > #define PSP_CMD_TIMEOUT_US (500 * USEC_PER_MSEC) > > > > +#define PSP_I2C_COOLDOWN_TIME_MS 100 > > + > > "cooldown" distract me thinking thermal management. Would semaphore > reservation time/timer fit better? Yes, it makes sense. I will change this here and in the commit message to "semaphore reservation timer". > > > +static void release_bus_now(void) > > +static void psp_release_i2c_bus_deferred(struct work_struct *work) > > +static DECLARE_DELAYED_WORK(release_queue, psp_release_i2c_bus_deferred); > > + > > I'd use the same namespace here. Perhaps _now can be dropped from the > name since the release_bus and release_bus_deferred are near to each > other and _deferred variant implies it's called after timeout. Right, release_bus_now -> release_bus. > > > + /* > > + * Send a release command to PSP if the cooldown timeout elapsed but x86 still > > + * owns the ctrlr. > > + */ > > Replace "ctrlr" -> "control" here since then it doesn't lead to think > is't some technical object like register etc. This is about "controller" not "control", but I think your comment is still applicable. Best Regards, Jan
Hi Jarko, Andriy,
Could you please take a look?
Best Regards,
Jan
pon., 25 lip 2022 o 10:03 Jan Dabros <jsd@semihalf.com> napisał(a):
>
> In order to optimize performance, limit amount of back and forth
> transactions between x86 and PSP. This is done by introduction of
> cooldown period - that is window in which x86 isn't releasing the bus
> immediately after each I2C transaction.
>
> In order to protect PSP from being starved while waiting for
> arbitration, after a programmed time bus is automatically released by a
> deferred function.
>
> Signed-off-by: Jan Dabros <jsd@semihalf.com>
> ---
> drivers/i2c/busses/i2c-designware-amdpsp.c | 68 +++++++++++++++++-----
> 1 file changed, 53 insertions(+), 15 deletions(-)
>
> diff --git a/drivers/i2c/busses/i2c-designware-amdpsp.c b/drivers/i2c/busses/i2c-designware-amdpsp.c
> index b624356c945f..2e1bb5ae72c3 100644
> --- a/drivers/i2c/busses/i2c-designware-amdpsp.c
> +++ b/drivers/i2c/busses/i2c-designware-amdpsp.c
> @@ -6,6 +6,7 @@
> #include <linux/io-64-nonatomic-lo-hi.h>
> #include <linux/psp-sev.h>
> #include <linux/types.h>
> +#include <linux/workqueue.h>
>
> #include <asm/msr.h>
>
> @@ -15,6 +16,8 @@
> #define PSP_MBOX_OFFSET 0x10570
> #define PSP_CMD_TIMEOUT_US (500 * USEC_PER_MSEC)
>
> +#define PSP_I2C_COOLDOWN_TIME_MS 100
> +
> #define PSP_I2C_REQ_BUS_CMD 0x64
> #define PSP_I2C_REQ_RETRY_CNT 400
> #define PSP_I2C_REQ_RETRY_DELAY_US (25 * USEC_PER_MSEC)
> @@ -240,6 +243,42 @@ static int psp_send_i2c_req(enum psp_i2c_req_type i2c_req_type)
> return ret;
> }
>
> +static void release_bus_now(void)
> +{
> + int status;
> +
> + if (!psp_i2c_sem_acquired)
> + return;
> +
> + status = psp_send_i2c_req(PSP_I2C_REQ_RELEASE);
> + if (status)
> + return;
> +
> + dev_dbg(psp_i2c_dev, "PSP semaphore held for %ums\n",
> + jiffies_to_msecs(jiffies - psp_i2c_sem_acquired));
> +
> + psp_i2c_sem_acquired = 0;
> +}
> +
> +static void psp_release_i2c_bus_deferred(struct work_struct *work)
> +{
> +
> + mutex_lock(&psp_i2c_access_mutex);
> +
> + /*
> + * If there is any pending transaction, cannot release the bus here.
> + * psp_release_i2c_bus will take care of this later.
> + */
> + if (psp_i2c_access_count)
> + goto cleanup;
> +
> + release_bus_now();
> +
> +cleanup:
> + mutex_unlock(&psp_i2c_access_mutex);
> +}
> +static DECLARE_DELAYED_WORK(release_queue, psp_release_i2c_bus_deferred);
> +
> static int psp_acquire_i2c_bus(void)
> {
> int status;
> @@ -250,21 +289,23 @@ static int psp_acquire_i2c_bus(void)
> if (psp_i2c_mbox_fail)
> goto cleanup;
>
> + psp_i2c_access_count++;
> +
> /*
> - * Simply increment usage counter and return if PSP semaphore was
> - * already taken by kernel.
> + * No need to request bus arbitration once we are inside cooldown
> + * period.
> */
> - if (psp_i2c_access_count) {
> - psp_i2c_access_count++;
> + if (psp_i2c_sem_acquired)
> goto cleanup;
> - }
>
> status = psp_send_i2c_req(PSP_I2C_REQ_ACQUIRE);
> if (status)
> goto cleanup;
>
> psp_i2c_sem_acquired = jiffies;
> - psp_i2c_access_count++;
> +
> + schedule_delayed_work(&release_queue,
> + msecs_to_jiffies(PSP_I2C_COOLDOWN_TIME_MS));
>
> /*
> * In case of errors with PSP arbitrator psp_i2c_mbox_fail variable is
> @@ -279,8 +320,6 @@ static int psp_acquire_i2c_bus(void)
>
> static void psp_release_i2c_bus(void)
> {
> - int status;
> -
> mutex_lock(&psp_i2c_access_mutex);
>
> /* Return early if mailbox was malfunctional */
> @@ -295,13 +334,12 @@ static void psp_release_i2c_bus(void)
> if (psp_i2c_access_count)
> goto cleanup;
>
> - /* Send a release command to PSP */
> - status = psp_send_i2c_req(PSP_I2C_REQ_RELEASE);
> - if (status)
> - goto cleanup;
> -
> - dev_dbg(psp_i2c_dev, "PSP semaphore held for %ums\n",
> - jiffies_to_msecs(jiffies - psp_i2c_sem_acquired));
> + /*
> + * Send a release command to PSP if the cooldown timeout elapsed but x86 still
> + * owns the ctrlr.
> + */
> + if (!delayed_work_pending(&release_queue))
> + release_bus_now();
>
> cleanup:
> mutex_unlock(&psp_i2c_access_mutex);
> --
> 2.37.1.359.gd136c6c3e2-goog
>
© 2016 - 2026 Red Hat, Inc.