Skip to contentSkip to conversation

MPFS system controller/mailbox fixes

PATCH Superseded Conor Dooley 3 participants 14 messages Jan 11, 2023 – Feb 17, 2023

Subsystems (4)

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore

Conor Dooley

author maintainer
#0 lore raw

cover MPFS system controller/mailbox fixes

Hey Jassi, all,

Here are some fixes for the system controller on PolarFire SoC that I ran into while implementing support for using the system controller to re-program the FPGA. A few are just minor bits that I fixed in passing, but the bulk of the patchset is changes to how the mailbox figures out if a "service" has completed.

Prior to implementing this particular functionality, the services requested from the system controller, via its mailbox interface, always triggered an interrupt when the system controller was finished with the service.

Unfortunately some of the services used to validate the FPGA images before programming them do not trigger an interrupt if they fail. For example, the service that checks whether an FPGA image is actually a newer version than what is already programmed, does not trigger an interrupt, unless the image is actually newer than the one currently programmed. If it has an earlier version, no interrupt is triggered and a status is set in the system controller's status register to signify the reason for the failure.

In order to differentiate between the service succeeding & the system controller being inoperative or otherwise unable to function, I had to switch the controller to poll a busy bit in the system controller's registers to see if it has completed a service.
This makes sense anyway, as the interrupt corresponds to "data ready" rather than "tx done", so I have changed the mailbox controller driver to do that & left the interrupt solely for signalling data ready. It just so happened that all of the services that I had worked with and tested up to this point were "infallible" & did not set a status, so the particular code paths were never tested.

Jassi, the mailbox and soc patches depend on each other, as the change in what the interrupt is used for requires changing the client driver's behaviour too, as mbox_send_message() will now return when the system controller is no longer busy rather than when the data is ready. I'm happy to send the lot via the soc tree with your Ack and/or reivew, if that also works you?

Secondly, I have a question about what to do if a service does fail, but not due to a timeout - eg the above example where the "new" image for the FPGA is actually older than the one that currently exists. Ideally, if a service fails due to something other than the transaction timing out, I would go and read the status registers to see what the cause of failure was.
I could not find a function in the mailbox framework that allows the client to request that sort of information from the client. Trying to do something with the auxiliary bus, or exporting some function to a device specific header seemed like a circumvention of the mailbox framework.
Do you think it would be a good idea to implement something like mbox_client_peek_status(struct mbox_chan *chan, void *data) to allow clients to request this type of information?

It'd certainly allow me to report the actual errors to the drivers implementing the service & make better decisions there about how to proceed.
Perhaps I have missed some way of doing this kind of thing that (should have been) staring me in the face!

Thanks,
Conor.

CC Conor Dooley <[email protected]>
CC Daire McNamara <[email protected]>
CC Jassi Brar <[email protected]>

Conor Dooley (7):
mailbox: mpfs: fix an incorrect mask width
mailbox: mpfs: switch to txdone_poll
mailbox: mpfs: ditch a useless busy check
soc: microchip: mpfs: fix some horrible alignment
soc: microchip: mpfs: use a consistent completion timeout
soc: microchip: mpfs: simplify error handling in
mpfs_blocking_transaction()
soc: microchip: mpfs: handle timeouts and failed services differently

 drivers/mailbox/mailbox-mpfs.c              | 25 +++++++----
 drivers/soc/microchip/mpfs-sys-controller.c | 48 +++++++++++++--------
 2 files changed, 47 insertions(+), 26 deletions(-)

base-commit: 88603b6dc419445847923fcb7fe5080067a30f98

Signature · 1 line
2.39.0
author maintainer
#1 lore raw

PATCH 1/7 mailbox: mpfs: fix an incorrect mask width

The system controller registers on PolarFire SoC are 32 bits wide, so 16 + 16 as the first input to GENMASK_ULL() gives a 33 bit wide mask. It probably should have been immediately obvious when it was pointed out during review that the width required using GENMASK_ULL() - but I scarcely knew what I was doing at the time and missed it. The mistake ends up being moot as it is a mask after all, but it is incorrect and should be fixed.

No functional change intended.

---
 drivers/mailbox/mailbox-mpfs.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/mailbox/mailbox-mpfs.c +2 -1
index 853901acaeec..d37560e91116 100644
@@ -39,7 +39,7 @@
 #define SCB_CTRL_NOTIFY_MASK BIT(SCB_CTRL_NOTIFY)
 
 #define SCB_CTRL_POS (16)
-#define SCB_CTRL_MASK GENMASK_ULL(SCB_CTRL_POS + SCB_MASK_WIDTH, SCB_CTRL_POS)
+#define SCB_CTRL_MASK GENMASK(SCB_CTRL_POS + SCB_MASK_WIDTH - 1, SCB_CTRL_POS)
 
 /* SCBCTRL service status register */
 
@@ -118,6 +118,7 @@ static int mpfs_mbox_send_data(struct mbox_chan *chan, void *data)
 	}
 
 	opt_sel = ((msg->mbox_offset << 7u) | (msg->cmd_opcode & 0x7fu));
+
 	tx_trigger = (opt_sel << SCB_CTRL_POS) & SCB_CTRL_MASK;
 	tx_trigger |= SCB_CTRL_REQ_MASK | SCB_STATUS_NOTIFY_MASK;
 	writel_relaxed(tx_trigger, mbox->ctrl_base + SERVICES_CR_OFFSET);
Signature · 1 line
2.39.0
author maintainer
#2 lore raw

PATCH 2/7 mailbox: mpfs: switch to txdone_poll

In reply to Conor Dooley

The system controller on PolarFire SoC has no interrupt to signify that the TX has been completed. The interrupt instead signals that a service requested by the mailbox client has succeeded. If a service fails, there will be no interrupt delivered.

Switch to polling the busy register to determine whether transmission has completed.

Fixes 83d7b1560810 ("mbox: add polarfire soc system controller mailbox")
---
 drivers/mailbox/mailbox-mpfs.c | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)
drivers/mailbox/mailbox-mpfs.c +10 -2
index d37560e91116..e0e825bdbad9 100644
@@ -79,6 +79,13 @@ static bool mpfs_mbox_busy(struct mpfs_mbox *mbox)
 	return status & SCB_STATUS_BUSY_MASK;
 }
 
+static bool mpfs_mbox_last_tx_done(struct mbox_chan *chan)
+{
+	struct mpfs_mbox *mbox = (struct mpfs_mbox *)chan->con_priv;
+
+	return !mpfs_mbox_busy(mbox);
+}
+
 static int mpfs_mbox_send_data(struct mbox_chan *chan, void *data)
 {
 	struct mpfs_mbox *mbox = (struct mpfs_mbox *)chan->con_priv;
@@ -183,7 +190,6 @@ static irqreturn_t mpfs_mbox_inbox_isr(int irq, void *data)
 
 	mpfs_mbox_rx_data(chan);
 
-	mbox_chan_txdone(chan, 0);
 	return IRQ_HANDLED;
 }
 
@@ -213,6 +219,7 @@ static const struct mbox_chan_ops mpfs_mbox_ops = {
 	.send_data = mpfs_mbox_send_data,
 	.startup = mpfs_mbox_startup,
 	.shutdown = mpfs_mbox_shutdown,
+	.last_tx_done = mpfs_mbox_last_tx_done,
 };
 
 static int mpfs_mbox_probe(struct platform_device *pdev)
@@ -248,7 +255,8 @@ static int mpfs_mbox_probe(struct platform_device *pdev)
 	mbox->controller.num_chans = 1;
 	mbox->controller.chans = mbox->chans;
 	mbox->controller.ops = &mpfs_mbox_ops;
-	mbox->controller.txdone_irq = true;
+	mbox->controller.txdone_poll = true;
+	mbox->controller.txpoll_period = 10u;
 
 	ret = devm_mbox_controller_register(&pdev->dev, &mbox->controller);
 	if (ret) {
Signature · 7 lines
2.39.0


_______________________________________________
linux-riscv mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-riscv
author maintainer
#3 lore raw

PATCH 3/7 mailbox: mpfs: ditch a useless busy check

In reply to Conor Dooley

mpfs_mbox_rx_data() already checks if the system controller is busy before attempting to do anything, so drop the second check before reading any data.

No functional change intended.

---
 drivers/mailbox/mailbox-mpfs.c | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)
drivers/mailbox/mailbox-mpfs.c +4 -6
index e0e825bdbad9..0d176aba3462 100644
@@ -170,12 +170,10 @@ static void mpfs_mbox_rx_data(struct mbox_chan *chan)
 	if (response->resp_status)
 		return;
 
-	if (!mpfs_mbox_busy(mbox)) {
-		for (i = 0; i < num_words; i++) {
-			response->resp_msg[i] =
-				readl_relaxed(mbox->mbox_base
-					      + mbox->resp_offset + i * 0x4);
-		}
+	for (i = 0; i < num_words; i++) {
+		response->resp_msg[i] =
+			readl_relaxed(mbox->mbox_base
+				      + mbox->resp_offset + i * 0x4);
 	}
 
 	mbox_chan_received_data(chan, response);
Signature · 7 lines
2.39.0


_______________________________________________
linux-riscv mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-riscv
author maintainer
#4 lore raw

PATCH 4/7 soc: microchip: mpfs: fix some horrible alignment

In reply to Conor Dooley

mpfs_sys_controller_delete() has some horrible alignment that upsets my OCD... Move the RHS of the assignment to a new line for greater satifaction.

---
 drivers/soc/microchip/mpfs-sys-controller.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/soc/microchip/mpfs-sys-controller.c +2 -2
index 6e20207b5756..12039cb38b33 100644
@@ -66,8 +66,8 @@ static void rx_callback(struct mbox_client *client, void *msg)
 
 static void mpfs_sys_controller_delete(struct kref *kref)
 {
-	struct mpfs_sys_controller *sys_controller = container_of(kref, struct mpfs_sys_controller,
-					       consumers);
+	struct mpfs_sys_controller *sys_controller =
+		container_of(kref, struct mpfs_sys_controller, consumers);
 
 	mbox_free_channel(sys_controller->chan);
 	kfree(sys_controller);
Signature · 7 lines
2.39.0


_______________________________________________
linux-riscv mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-riscv
author maintainer
#5 lore raw

PATCH 5/7 soc: microchip: mpfs: use a consistent completion timeout

In reply to Conor Dooley

Completion timeouts use jiffies, so passing a number directly will produce inconsistent timeouts depending on config. Define the timeout in ms and convert it to jiffies instead.

---
 drivers/soc/microchip/mpfs-sys-controller.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)
drivers/soc/microchip/mpfs-sys-controller.c +5 -1
index 12039cb38b33..738ecd624d64 100644
@@ -11,12 +11,15 @@
 #include <linux/slab.h>
 #include <linux/kref.h>
 #include <linux/module.h>
+#include <linux/jiffies.h>
 #include <linux/interrupt.h>
 #include <linux/of_platform.h>
 #include <linux/mailbox_client.h>
 #include <linux/platform_device.h>
 #include <soc/microchip/mpfs.h>
 
+#define MPFS_SYS_CTRL_TIMEOUT_MS 100
+
 static DEFINE_MUTEX(transaction_lock);
 
 struct mpfs_sys_controller {
@@ -28,6 +31,7 @@ struct mpfs_sys_controller {
 
 int mpfs_blocking_transaction(struct mpfs_sys_controller *sys_controller, struct mpfs_mss_msg *msg)
 {
+	unsigned long timeout = msecs_to_jiffies(MPFS_SYS_CTRL_TIMEOUT_MS);
 	int ret, err;
 
 	err = mutex_lock_interruptible(&transaction_lock);
@@ -38,7 +42,7 @@ int mpfs_blocking_transaction(struct mpfs_sys_controller *sys_controller, struct
 
 	ret = mbox_send_message(sys_controller->chan, msg);
 	if (ret >= 0) {
-		if (wait_for_completion_timeout(&sys_controller->c, HZ)) {
+		if (wait_for_completion_timeout(&sys_controller->c, timeout)) {
 			ret = 0;
 		} else {
 			ret = -ETIMEDOUT;
Signature · 7 lines
2.39.0


_______________________________________________
linux-riscv mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-riscv
author maintainer
#6 lore raw

PATCH 6/7 soc: microchip: mpfs: simplify error handling in mpfs_blocking_transaction()

In reply to Conor Dooley

The error handling has a kinda weird nested-if setup that is not really adding anything. Switch it to more of an early return arrangement as a predatory step for adding different handing for timeouts and failed services.

---
 drivers/soc/microchip/mpfs-sys-controller.c | 28 ++++++++++-----------
 1 file changed, 13 insertions(+), 15 deletions(-)
drivers/soc/microchip/mpfs-sys-controller.c +13 -15
index 738ecd624d64..4aadd05769d2 100644
@@ -32,28 +32,26 @@ struct mpfs_sys_controller {
 int mpfs_blocking_transaction(struct mpfs_sys_controller *sys_controller, struct mpfs_mss_msg *msg)
 {
 	unsigned long timeout = msecs_to_jiffies(MPFS_SYS_CTRL_TIMEOUT_MS);
-	int ret, err;
+	int ret;
 
-	err = mutex_lock_interruptible(&transaction_lock);
-	if (err)
-		return err;
+	ret = mutex_lock_interruptible(&transaction_lock);
+	if (ret)
+		return ret;
 
 	reinit_completion(&sys_controller->c);
 
 	ret = mbox_send_message(sys_controller->chan, msg);
-	if (ret >= 0) {
-		if (wait_for_completion_timeout(&sys_controller->c, timeout)) {
-			ret = 0;
-		} else {
-			ret = -ETIMEDOUT;
-			dev_warn(sys_controller->client.dev,
-				 "MPFS sys controller transaction timeout\n");
-		}
-	} else {
-		dev_err(sys_controller->client.dev,
-			"mpfs sys controller transaction returned %d\n", ret);
+	if (ret < 0)
+		goto out;
+
+	ret = 0; /* mbox_send_message returns postitive integers on success */
+	if (!wait_for_completion_timeout(&sys_controller->c, timeout)) {
+		ret = -ETIMEDOUT;
+		dev_warn(sys_controller->client.dev,
+			 "MPFS sys controller transaction timeout\n");
 	}
 
+out:
 	mutex_unlock(&transaction_lock);
 
 	return ret;
Signature · 7 lines
2.39.0


_______________________________________________
linux-riscv mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-riscv
author maintainer
#7 lore raw

PATCH 7/7 soc: microchip: mpfs: handle timeouts and failed services differently

In reply to Conor Dooley

The system controller will only deliver an interrupt if a service succeeds. This leaves us in the unfortunate position with current code where there is no way to differentiate between a legitimate timeout where the service has not completed & where it has completed, but failed.

mbox_send_message() has its own completion, and it will time out of the system controller does not lower the busy flag. In this case, a timeout has occurred and the error can be propagated back to the caller.

If the busy flag is lowered, but no interrupt has arrived to trigger the rx callback, the service can be deemed to have failed. Report EBADMSG in this case so that callers can differentiate.

---
 drivers/soc/microchip/mpfs-sys-controller.c | 18 +++++++++++++++---
 1 file changed, 15 insertions(+), 3 deletions(-)
drivers/soc/microchip/mpfs-sys-controller.c +15 -3
index 4aadd05769d2..75422db75fe5 100644
@@ -41,14 +41,25 @@ int mpfs_blocking_transaction(struct mpfs_sys_controller *sys_controller, struct
 	reinit_completion(&sys_controller->c);
 
 	ret = mbox_send_message(sys_controller->chan, msg);
-	if (ret < 0)
+	if (ret < 0) {
+		dev_warn(sys_controller->client.dev,
+			 "MPFS sys controller service timeout\n");
 		goto out;
+	}
 
 	ret = 0; /* mbox_send_message returns postitive integers on success */
+
+	/*
+	 * Unfortunately, the system controller will only deliver an interrupt
+	 * if a service succeeds. mbox_send_message() will block until the busy
+	 * flag is gone. If the busy flag is gone but no interrupt has arrived
+	 * to trigger the rx callback then the service can be deemed to have
+	 * failed.
+	 */
 	if (!wait_for_completion_timeout(&sys_controller->c, timeout)) {
-		ret = -ETIMEDOUT;
+		ret = -EBADMSG;
 		dev_warn(sys_controller->client.dev,
-			 "MPFS sys controller transaction timeout\n");
+			 "MPFS sys controller service failed\n");
 	}
 
 out:
@@ -106,6 +117,7 @@ static int mpfs_sys_controller_probe(struct platform_device *pdev)
 	sys_controller->client.dev = dev;
 	sys_controller->client.rx_callback = rx_callback;
 	sys_controller->client.tx_block = 1U;
+	sys_controller->client.tx_tout = msecs_to_jiffies(MPFS_SYS_CTRL_TIMEOUT_MS);
 
 	sys_controller->chan = mbox_request_channel(&sys_controller->client, 0);
 	if (IS_ERR(sys_controller->chan)) {
Signature · 7 lines
2.39.0


_______________________________________________
linux-riscv mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-riscv
maintainer
#8 lore raw
In reply to Conor Dooley
Quoted 13 lines · Conor Dooley

Hey Jassi, all,

Here are some fixes for the system controller on PolarFire SoC that I ran into while implementing support for using the system controller to re-program the FPGA. A few are just minor bits that I fixed in passing, but the bulk of the patchset is changes to how the mailbox figures out if a "service" has completed.

Prior to implementing this particular functionality, the services requested from the system controller, via its mailbox interface, always triggered an interrupt when the system controller was finished with the service.

Quoted 8 lines

Unfortunately some of the services used to validate the FPGA images before programming them do not trigger an interrupt if they fail. For example, the service that checks whether an FPGA image is actually a newer version than what is already programmed, does not trigger an interrupt, unless the image is actually newer than the one currently programmed. If it has an earlier version, no interrupt is triggered and a status is set in the system controller's status register to signify the reason for the failure.

I think, with how things currently are, the timeout is insufficient. I've noticed some services taking longer (significantly) longer than what I have provisioned for.

I'll try to find an upper bound and respin a v2. Questions below are still valid either way!

Thanks,
Conor.

Quoted 58 lines

In order to differentiate between the service succeeding & the system controller being inoperative or otherwise unable to function, I had to switch the controller to poll a busy bit in the system controller's registers to see if it has completed a service.
This makes sense anyway, as the interrupt corresponds to "data ready" rather than "tx done", so I have changed the mailbox controller driver to do that & left the interrupt solely for signalling data ready. It just so happened that all of the services that I had worked with and tested up to this point were "infallible" & did not set a status, so the particular code paths were never tested.

Jassi, the mailbox and soc patches depend on each other, as the change in what the interrupt is used for requires changing the client driver's behaviour too, as mbox_send_message() will now return when the system controller is no longer busy rather than when the data is ready. I'm happy to send the lot via the soc tree with your Ack and/or reivew, if that also works you?

Secondly, I have a question about what to do if a service does fail, but not due to a timeout - eg the above example where the "new" image for the FPGA is actually older than the one that currently exists. Ideally, if a service fails due to something other than the transaction timing out, I would go and read the status registers to see what the cause of failure was.
I could not find a function in the mailbox framework that allows the client to request that sort of information from the client. Trying to do something with the auxiliary bus, or exporting some function to a device specific header seemed like a circumvention of the mailbox framework.
Do you think it would be a good idea to implement something like mbox_client_peek_status(struct mbox_chan *chan, void *data) to allow clients to request this type of information?

It'd certainly allow me to report the actual errors to the drivers implementing the service & make better decisions there about how to proceed.
Perhaps I have missed some way of doing this kind of thing that (should have been) staring me in the face!

Thanks,
Conor.

CC Conor Dooley <[email protected]>
CC Daire McNamara <[email protected]>
CC Jassi Brar <[email protected]>

Conor Dooley (7):
mailbox: mpfs: fix an incorrect mask width
mailbox: mpfs: switch to txdone_poll
mailbox: mpfs: ditch a useless busy check
soc: microchip: mpfs: fix some horrible alignment
soc: microchip: mpfs: use a consistent completion timeout
soc: microchip: mpfs: simplify error handling in
mpfs_blocking_transaction()
soc: microchip: mpfs: handle timeouts and failed services differently

Quoted 9 lines
 drivers/mailbox/mailbox-mpfs.c              | 25 +++++++----
 drivers/soc/microchip/mpfs-sys-controller.c | 48 +++++++++++++--------
 2 files changed, 47 insertions(+), 26 deletions(-)

base-commit: 88603b6dc419445847923fcb7fe5080067a30f98

Signature · 1 line
2.39.0

_______________________________________________
linux-riscv mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-riscv

maintainer
#9 lore raw
In reply to Conor Dooley
Quoted 12 lines · Conor Dooley

In order to differentiate between the service succeeding & the system controller being inoperative or otherwise unable to function, I had to switch the controller to poll a busy bit in the system controller's registers to see if it has completed a service.
This makes sense anyway, as the interrupt corresponds to "data ready" rather than "tx done", so I have changed the mailbox controller driver to do that & left the interrupt solely for signalling data ready. It just so happened that all of the services that I had worked with and tested up to this point were "infallible" & did not set a status, so the particular code paths were never tested.

Quoted 7 lines

Jassi, the mailbox and soc patches depend on each other, as the change in what the interrupt is used for requires changing the client driver's behaviour too, as mbox_send_message() will now return when the system controller is no longer busy rather than when the data is ready. I'm happy to send the lot via the soc tree with your Ack and/or reivew, if that also works you?

Ok, let me review them and get back to you.

Quoted 6 lines

Secondly, I have a question about what to do if a service does fail, but not due to a timeout - eg the above example where the "new" image for the FPGA is actually older than the one that currently exists. Ideally, if a service fails due to something other than the transaction timing out, I would go and read the status registers to see what the cause of failure was.

Quoted 9 lines

I could not find a function in the mailbox framework that allows the client to request that sort of information from the client. Trying to do something with the auxiliary bus, or exporting some function to a device specific header seemed like a circumvention of the mailbox framework.
Do you think it would be a good idea to implement something like mbox_client_peek_status(struct mbox_chan *chan, void *data) to allow clients to request this type of information?

.last_tx_done() is supposed to make sure everything is ok. If the expected status bit is "sometimes not set", that means that bit is not the complete status. You have to check multiple registers to detect if and what caused the failure.

Cheers.

maintainer
#10 lore raw
Quoted 13 lines · Jassi Brar
Quoted 12 lines · Conor Dooley

In order to differentiate between the service succeeding & the system controller being inoperative or otherwise unable to function, I had to switch the controller to poll a busy bit in the system controller's registers to see if it has completed a service.
This makes sense anyway, as the interrupt corresponds to "data ready" rather than "tx done", so I have changed the mailbox controller driver to do that & left the interrupt solely for signalling data ready. It just so happened that all of the services that I had worked with and tested up to this point were "infallible" & did not set a status, so the particular code paths were never tested.

Quoted 8 lines
Quoted 7 lines

Jassi, the mailbox and soc patches depend on each other, as the change in what the interrupt is used for requires changing the client driver's behaviour too, as mbox_send_message() will now return when the system controller is no longer busy rather than when the data is ready. I'm happy to send the lot via the soc tree with your Ack and/or reivew, if that also works you?

Ok, let me review them and get back to you.

FYI, I did sent a v2 on Friday:
https://lore.kernel.org/all/[email protected]/

The change is just a timeout duration though.

Quoted 15 lines
Quoted 6 lines

Secondly, I have a question about what to do if a service does fail, but not due to a timeout - eg the above example where the "new" image for the FPGA is actually older than the one that currently exists. Ideally, if a service fails due to something other than the transaction timing out, I would go and read the status registers to see what the cause of failure was.

Quoted 9 lines

I could not find a function in the mailbox framework that allows the client to request that sort of information from the client. Trying to do something with the auxiliary bus, or exporting some function to a device specific header seemed like a circumvention of the mailbox framework.
Do you think it would be a good idea to implement something like mbox_client_peek_status(struct mbox_chan *chan, void *data) to allow clients to request this type of information?

Quoted 1 line

.last_tx_done() is supposed to make sure everything is ok.

Hm, might've explained badly as I think you've misunderstood. Or (see below) I might have mistakenly thought that last_tx_done() was only meant to signify that tx was done.

Anyways, I'll try to clarify.
Some services don't set a status, but whether a status is, or isn't, set has nothing to do with whether the service has completed. One service that sets a status is "Authenticate Bitstream". This service sets a status of 0x0 if the bitstream in question is okay _and_ something that the FPGA can be upgraded to. It returns a failure of 0x18 if the bitstream is valid _but_ is the same as that currently programmed. (and of course a whole host of other possible errors in-between)

These statuses, and whether they are a bad outcome or not, is dependant on the service and I don't think should be handled in the mailbox controller driver.

Quoted 2 lines

If the expected status bit is "sometimes not set", that means that bit is not the complete status.

If the "busy" bit goes low, then the transmission must be complete, there should be no need to check other bits for *completion*, but...

Quoted 2 lines

You have to check multiple registers to
detect if and what caused the failure.

...maybe I have just misunderstood the role of .last_tx_done(). The comment in mailbox-controller.h lead me to believe that it was used just to check if it had been completed.

Am I allowed to use .last_tx_done() to pass information back to the mailbox client? If I could, that'd certainly be a nice way to get the information on whether the service failed etc.

Hopefully that, plus when you have a chance to look at the code, will make what I am asking about a little clearer!

Thanks,
Conor.

maintainer
#11 lore raw

Hey Jassi,

Quoted 75 lines · Conor Dooley
Quoted 13 lines · Jassi Brar
Quoted 12 lines · Conor Dooley

In order to differentiate between the service succeeding & the system controller being inoperative or otherwise unable to function, I had to switch the controller to poll a busy bit in the system controller's registers to see if it has completed a service.
This makes sense anyway, as the interrupt corresponds to "data ready" rather than "tx done", so I have changed the mailbox controller driver to do that & left the interrupt solely for signalling data ready. It just so happened that all of the services that I had worked with and tested up to this point were "infallible" & did not set a status, so the particular code paths were never tested.

Quoted 8 lines
Quoted 7 lines

Jassi, the mailbox and soc patches depend on each other, as the change in what the interrupt is used for requires changing the client driver's behaviour too, as mbox_send_message() will now return when the system controller is no longer busy rather than when the data is ready. I'm happy to send the lot via the soc tree with your Ack and/or reivew, if that also works you?

Ok, let me review them and get back to you.

FYI, I did sent a v2 on Friday:
https://lore.kernel.org/all/[email protected]/

The change is just a timeout duration though.

Quoted 15 lines
Quoted 6 lines

Secondly, I have a question about what to do if a service does fail, but not due to a timeout - eg the above example where the "new" image for the FPGA is actually older than the one that currently exists. Ideally, if a service fails due to something other than the transaction timing out, I would go and read the status registers to see what the cause of failure was.

Quoted 9 lines

I could not find a function in the mailbox framework that allows the client to request that sort of information from the client. Trying to do something with the auxiliary bus, or exporting some function to a device specific header seemed like a circumvention of the mailbox framework.
Do you think it would be a good idea to implement something like mbox_client_peek_status(struct mbox_chan *chan, void *data) to allow clients to request this type of information?

Quoted 1 line

.last_tx_done() is supposed to make sure everything is ok.

Hm, might've explained badly as I think you've misunderstood. Or (see below) I might have mistakenly thought that last_tx_done() was only meant to signify that tx was done.

Anyways, I'll try to clarify.
Some services don't set a status, but whether a status is, or isn't, set has nothing to do with whether the service has completed. One service that sets a status is "Authenticate Bitstream". This service sets a status of 0x0 if the bitstream in question is okay _and_ something that the FPGA can be upgraded to. It returns a failure of 0x18 if the bitstream is valid _but_ is the same as that currently programmed. (and of course a whole host of other possible errors in-between)

These statuses, and whether they are a bad outcome or not, is dependant on the service and I don't think should be handled in the mailbox controller driver.

Quoted 2 lines

If the expected status bit is "sometimes not set", that means that bit is not the complete status.

If the "busy" bit goes low, then the transmission must be complete, there should be no need to check other bits for *completion*, but...

Quoted 2 lines

You have to check multiple registers to
detect if and what caused the failure.

...maybe I have just misunderstood the role of .last_tx_done(). The comment in mailbox-controller.h lead me to believe that it was used just to check if it had been completed.

Quoted 6 lines

Am I allowed to use .last_tx_done() to pass information back to the mailbox client? If I could, that'd certainly be a nice way to get the information on whether the service failed etc.

Hopefully that, plus when you have a chance to look at the code, will make what I am asking about a little clearer!

Just wondering if you've had a chance to look at this again! I know it's missed the merge window this time around but I would like to get this behaviour fixed as other work depends on it.

Thanks,
Conor.

maintainer
#12 lore raw
Quoted 52 lines · Conor Dooley
Quoted 52 lines
Quoted 16 lines
Quoted 16 lines

Secondly, I have a question about what to do if a service does fail, but not due to a timeout - eg the above example where the "new" image for the FPGA is actually older than the one that currently exists. Ideally, if a service fails due to something other than the transaction timing out, I would go and read the status registers to see what the cause of failure was.
I could not find a function in the mailbox framework that allows the client to request that sort of information from the client. Trying to do something with the auxiliary bus, or exporting some function to a device specific header seemed like a circumvention of the mailbox framework.
Do you think it would be a good idea to implement something like mbox_client_peek_status(struct mbox_chan *chan, void *data) to allow clients to request this type of information?

Quoted 1 line

.last_tx_done() is supposed to make sure everything is ok.

Hm, might've explained badly as I think you've misunderstood. Or (see below) I might have mistakenly thought that last_tx_done() was only meant to signify that tx was done.

Anyways, I'll try to clarify.
Some services don't set a status, but whether a status is, or isn't, set has nothing to do with whether the service has completed. One service that sets a status is "Authenticate Bitstream". This service sets a status of 0x0 if the bitstream in question is okay _and_ something that the FPGA can be upgraded to. It returns a failure of 0x18 if the bitstream is valid _but_ is the same as that currently programmed. (and of course a whole host of other possible errors in-between)

These statuses, and whether they are a bad outcome or not, is dependant on the service and I don't think should be handled in the mailbox controller driver.

Quoted 2 lines

If the expected status bit is "sometimes not set", that means that bit is not the complete status.

If the "busy" bit goes low, then the transmission must be complete, there should be no need to check other bits for *completion*, but...

Quoted 2 lines

You have to check multiple registers to
detect if and what caused the failure.

...maybe I have just misunderstood the role of .last_tx_done(). The comment in mailbox-controller.h lead me to believe that it was used just to check if it had been completed.

Am I allowed to use .last_tx_done() to pass information back to the mailbox client? If I could, that'd certainly be a nice way to get the information on whether the service failed etc.

Quoted 7 lines
Quoted 2 lines

Hopefully that, plus when you have a chance to look at the code, will make what I am asking about a little clearer!

Just wondering if you've had a chance to look at this again! I know it's missed the merge window this time around but I would like to get this behaviour fixed as other work depends on it.

My opinion about adding a new api just to accommodate remote f/w's behaviour change across updates is still no. last_tx_done() is more abstract than you think -- it has to play with dozens of behaviors of remotes. So may just wrap your whatever logic, of "tx is done", in that.

This query within the patchset threw me off -- I thought you needed the new api for the patchset, so I didn't look further. Looking at it now, I am ok with applying Patches 1,2 and 3. If you want.

cheers.

author maintainer
#13 lore raw
Quoted 60 lines · Jassi Brar
Quoted 52 lines · Conor Dooley
Quoted 52 lines
Quoted 16 lines
Quoted 16 lines

Secondly, I have a question about what to do if a service does fail, but not due to a timeout - eg the above example where the "new" image for the FPGA is actually older than the one that currently exists. Ideally, if a service fails due to something other than the transaction timing out, I would go and read the status registers to see what the cause of failure was.
I could not find a function in the mailbox framework that allows the client to request that sort of information from the client. Trying to do something with the auxiliary bus, or exporting some function to a device specific header seemed like a circumvention of the mailbox framework.
Do you think it would be a good idea to implement something like mbox_client_peek_status(struct mbox_chan *chan, void *data) to allow clients to request this type of information?

Quoted 1 line

.last_tx_done() is supposed to make sure everything is ok.

Hm, might've explained badly as I think you've misunderstood. Or (see below) I might have mistakenly thought that last_tx_done() was only meant to signify that tx was done.

Anyways, I'll try to clarify.
Some services don't set a status, but whether a status is, or isn't, set has nothing to do with whether the service has completed. One service that sets a status is "Authenticate Bitstream". This service sets a status of 0x0 if the bitstream in question is okay _and_ something that the FPGA can be upgraded to. It returns a failure of 0x18 if the bitstream is valid _but_ is the same as that currently programmed. (and of course a whole host of other possible errors in-between)

These statuses, and whether they are a bad outcome or not, is dependant on the service and I don't think should be handled in the mailbox controller driver.

Quoted 2 lines

If the expected status bit is "sometimes not set", that means that bit is not the complete status.

If the "busy" bit goes low, then the transmission must be complete, there should be no need to check other bits for *completion*, but...

Quoted 2 lines

You have to check multiple registers to
detect if and what caused the failure.

...maybe I have just misunderstood the role of .last_tx_done(). The comment in mailbox-controller.h lead me to believe that it was used just to check if it had been completed.

Am I allowed to use .last_tx_done() to pass information back to the mailbox client? If I could, that'd certainly be a nice way to get the information on whether the service failed etc.

Quoted 7 lines
Quoted 2 lines

Hopefully that, plus when you have a chance to look at the code, will make what I am asking about a little clearer!

Just wondering if you've had a chance to look at this again! I know it's missed the merge window this time around but I would like to get this behaviour fixed as other work depends on it.

Quoted 5 lines

My opinion about adding a new api just to accommodate remote f/w's behaviour change across updates is still no. last_tx_done() is more abstract than you think -- it has to play with dozens of behaviors of remotes. So may just wrap your whatever logic, of "tx is done", in that.

Okay, that's fine. I'd rather not add a new API, so adding that to last_tx_done() is fine by me! I just wasn't sure from your earlier reply if that was okay.

Quoted 2 lines

This query within the patchset threw me off -- I thought you needed the new api for the patchset, so I didn't look further.

Ahh, sorry. The query was about improving things to report an accurate status rather than only timeouts. What's here *works* but is sub-optimal.

Quoted 1 line

Looking at it now, I am ok with applying Patches 1,2 and 3. If you want.

Ehh, the whole thing needs to go together to avoid breaking behaviour, so, given the merge window is next week, I'd rather rework it to report the actual status from last_tx_done().

Thanks!