* [RESEND v2 RFC 3/5] i2c: mv64xxx: Refactor FSM
@ 2024-03-19 22:52 Sam Edwards
2024-03-20 20:10 ` kernel test robot
2024-03-21 3:56 ` kernel test robot
0 siblings, 2 replies; 3+ messages in thread
From: Sam Edwards @ 2024-03-19 22:52 UTC (permalink / raw)
To: Gregory CLEMENT, Andi Shyti; +Cc: linux-i2c, linux-kernel
Conceptually, there are two FSMs here: a hardware FSM in the MV64XXX
itself, and a software FSM in the driver. The current software FSM is
not a "real" FSM: it is just using the hardware status to decide what to
do next, and the `state` is mostly unused.
There are two drawbacks to this approach:
1) If the hardware returns an unexpected status, the driver will accept
it blindly, allowing bugs to go unnoticed and complicating testing.
2) The driver FSM cannot have states/transitions not represented in
hardware.
Rework this by making the hardware status decoder state-aware, and
introducing an enum of "events" which can be fed to the driver FSM that
reflect the hardware events deduced by the status decoder. Any
unexpected status results in an "invalid" event, which triggers the
driver's error recovery. The state machine logic is otherwise the same:
the sequence of actions emitted by the FSM is unchanged by this patch.
Note: The meaning of bytes_left in reads is now the number of byte reads
left to *start* on the hardware, not the number of bytes left to be read
from the data register.
Signed-off-by: Sam Edwards <sam@turingpi.com>
---
drivers/i2c/busses/i2c-mv64xxx.c | 270 +++++++++++++++++++++----------
1 file changed, 185 insertions(+), 85 deletions(-)
diff --git a/drivers/i2c/busses/i2c-mv64xxx.c b/drivers/i2c/busses/i2c-mv64xxx.c
index bb048e655be7..3ae74160001d 100644
--- a/drivers/i2c/busses/i2c-mv64xxx.c
+++ b/drivers/i2c/busses/i2c-mv64xxx.c
@@ -4,10 +4,12 @@
*
* Author: Mark A. Greer <mgreer@mvista.com>
*
- * 2005 (c) MontaVista, Software, Inc. This file is licensed under
- * the terms of the GNU General Public License version 2. This program
- * is licensed "as is" without any warranty of any kind, whether express
- * or implied.
+ * 2005 (c) MontaVista, Software, Inc.
+ * Copyright (c) 2024 Turing Machines, Inc.
+ *
+ * This file is licensed under the terms of the GNU General Public License v2.
+ * This program is licensed "as is" without any warranty of any kind, whether
+ * express or implied.
*/
#include <linux/kernel.h>
#include <linux/slab.h>
@@ -86,12 +88,24 @@
enum mv64xxx_i2c_state {
MV64XXX_I2C_STATE_INVALID,
MV64XXX_I2C_STATE_IDLE,
- MV64XXX_I2C_STATE_WAITING_FOR_START_COND,
- MV64XXX_I2C_STATE_WAITING_FOR_RESTART,
- MV64XXX_I2C_STATE_WAITING_FOR_ADDR_1_ACK,
- MV64XXX_I2C_STATE_WAITING_FOR_ADDR_2_ACK,
- MV64XXX_I2C_STATE_WAITING_FOR_SLAVE_ACK,
- MV64XXX_I2C_STATE_WAITING_FOR_SLAVE_DATA,
+ MV64XXX_I2C_STATE_START,
+ MV64XXX_I2C_STATE_RESTART,
+ MV64XXX_I2C_STATE_SEND_ADDR_1,
+ MV64XXX_I2C_STATE_SEND_ADDR_2,
+ MV64XXX_I2C_STATE_WRITE,
+ MV64XXX_I2C_STATE_READ,
+};
+
+/* Driver events */
+enum mv64xxx_i2c_event {
+ MV64XXX_I2C_EVENT_INVALID,
+ MV64XXX_I2C_EVENT_STARTED,
+ MV64XXX_I2C_EVENT_ADDR_ACK,
+ MV64XXX_I2C_EVENT_ADDR_NO_ACK,
+ MV64XXX_I2C_EVENT_WR_ACK,
+ MV64XXX_I2C_EVENT_WR_NO_ACK,
+ MV64XXX_I2C_EVENT_RD_ACKED,
+ MV64XXX_I2C_EVENT_RD_UNACKED,
};
/* Driver actions */
@@ -232,9 +246,73 @@ mv64xxx_i2c_hw_init(struct mv64xxx_i2c_data *drv_data)
drv_data->state = MV64XXX_I2C_STATE_IDLE;
}
+static enum mv64xxx_i2c_event
+mv64xxx_i2c_decode_status(struct mv64xxx_i2c_data *drv_data, u32 status)
+{
+ /* Decode status to event (state-driven; catches unexpected status) */
+ switch (drv_data->state) {
+ case MV64XXX_I2C_STATE_RESTART:
+ case MV64XXX_I2C_STATE_START:
+ if (status == MV64XXX_I2C_STATUS_MAST_START ||
+ status == MV64XXX_I2C_STATUS_MAST_REPEAT_START)
+ return MV64XXX_I2C_EVENT_STARTED;
+ return MV64XXX_I2C_EVENT_INVALID;
+
+ case MV64XXX_I2C_STATE_SEND_ADDR_1:
+ if (drv_data->msg->flags & I2C_M_RD) {
+ if (status == MV64XXX_I2C_STATUS_MAST_RD_ADDR_ACK)
+ return MV64XXX_I2C_EVENT_ADDR_ACK;
+ else if (status == MV64XXX_I2C_STATUS_MAST_RD_ADDR_NO_ACK)
+ return MV64XXX_I2C_EVENT_ADDR_NO_ACK;
+ } else {
+ if (status == MV64XXX_I2C_STATUS_MAST_WR_ADDR_ACK)
+ return MV64XXX_I2C_EVENT_ADDR_ACK;
+ else if (status == MV64XXX_I2C_STATUS_MAST_WR_ADDR_NO_ACK)
+ return MV64XXX_I2C_EVENT_ADDR_NO_ACK;
+ }
+ return MV64XXX_I2C_EVENT_INVALID;
+
+ case MV64XXX_I2C_STATE_SEND_ADDR_2:
+ if (drv_data->msg->flags & I2C_M_RD) {
+ if (status == MV64XXX_I2C_STATUS_MAST_RD_ADDR_2_ACK)
+ return MV64XXX_I2C_EVENT_ADDR_ACK;
+ else if (status == MV64XXX_I2C_STATUS_MAST_RD_ADDR_2_NO_ACK)
+ return MV64XXX_I2C_EVENT_ADDR_NO_ACK;
+ } else {
+ if (status == MV64XXX_I2C_STATUS_MAST_WR_ADDR_2_ACK)
+ return MV64XXX_I2C_EVENT_ADDR_ACK;
+ else if (status == MV64XXX_I2C_STATUS_MAST_WR_ADDR_2_NO_ACK)
+ return MV64XXX_I2C_EVENT_ADDR_NO_ACK;
+ }
+ return MV64XXX_I2C_EVENT_INVALID;
+
+ case MV64XXX_I2C_STATE_WRITE:
+ if (status == MV64XXX_I2C_STATUS_MAST_WR_ACK)
+ return MV64XXX_I2C_EVENT_WR_ACK;
+ else if (status == MV64XXX_I2C_STATUS_MAST_WR_NO_ACK)
+ return MV64XXX_I2C_EVENT_ADDR_NO_ACK;
+ return MV64XXX_I2C_EVENT_INVALID;
+
+ case MV64XXX_I2C_STATE_READ:
+ if (status == MV64XXX_I2C_STATUS_MAST_RD_DATA_ACK)
+ return MV64XXX_I2C_EVENT_RD_ACKED;
+ else if (status == MV64XXX_I2C_STATUS_MAST_RD_DATA_NO_ACK)
+ return MV64XXX_I2C_EVENT_RD_UNACKED;
+ return MV64XXX_I2C_EVENT_INVALID;
+
+ default:
+ return MV64XXX_I2C_EVENT_INVALID;
+ }
+}
+
static void
mv64xxx_i2c_fsm(struct mv64xxx_i2c_data *drv_data, u32 status)
{
+ enum mv64xxx_i2c_event event;
+ enum mv64xxx_i2c_state prev_state = drv_data->state;
+
+ drv_data->action = MV64XXX_I2C_ACTION_INVALID;
+
/*
* If state is idle, then this is likely the remnants of an old
* operation that driver has given up on or the user has killed.
@@ -245,99 +323,121 @@ mv64xxx_i2c_fsm(struct mv64xxx_i2c_data *drv_data, u32 status)
return;
}
- /* The status from the ctlr [mostly] tells us what to do next */
- switch (status) {
- /* Start condition interrupt */
- case MV64XXX_I2C_STATUS_MAST_START: /* 0x08 */
- case MV64XXX_I2C_STATUS_MAST_REPEAT_START: /* 0x10 */
- drv_data->action = MV64XXX_I2C_ACTION_SEND_ADDR_1;
- drv_data->state = MV64XXX_I2C_STATE_WAITING_FOR_ADDR_1_ACK;
+ /*
+ * The FSM is broken into 3 parts:
+ * 1) Decode `status` to determine the underlying hardware event
+ * 2) Handle hardware event driven state transitions
+ * 3) Perform internal state transitions and action emission
+ */
+ event = mv64xxx_i2c_decode_status(drv_data, status);
+
+ /* Handle event; determine state transition */
+ switch (event) {
+ case MV64XXX_I2C_EVENT_STARTED:
+ drv_data->state = MV64XXX_I2C_STATE_SEND_ADDR_1;
break;
- /* Performing a write */
- case MV64XXX_I2C_STATUS_MAST_WR_ADDR_ACK: /* 0x18 */
- if (drv_data->msg->flags & I2C_M_TEN) {
- drv_data->action = MV64XXX_I2C_ACTION_SEND_ADDR_2;
- drv_data->state =
- MV64XXX_I2C_STATE_WAITING_FOR_ADDR_2_ACK;
- break;
- }
- fallthrough;
- case MV64XXX_I2C_STATUS_MAST_WR_ADDR_2_ACK: /* 0xd0 */
- case MV64XXX_I2C_STATUS_MAST_WR_ACK: /* 0x28 */
- if ((drv_data->bytes_left == 0)
- || (drv_data->aborting
- && (drv_data->byte_posn != 0))) {
- if (drv_data->send_stop || drv_data->aborting) {
- drv_data->action = MV64XXX_I2C_ACTION_SEND_STOP;
- drv_data->state = MV64XXX_I2C_STATE_IDLE;
- } else {
- drv_data->action =
- MV64XXX_I2C_ACTION_SEND_RESTART;
- drv_data->state =
- MV64XXX_I2C_STATE_WAITING_FOR_RESTART;
- }
- } else {
- drv_data->action = MV64XXX_I2C_ACTION_SEND_DATA;
- drv_data->state =
- MV64XXX_I2C_STATE_WAITING_FOR_SLAVE_ACK;
- drv_data->bytes_left--;
- }
+ case MV64XXX_I2C_EVENT_ADDR_ACK:
+ if ((drv_data->state == MV64XXX_I2C_STATE_SEND_ADDR_1)
+ && (drv_data->msg->flags & I2C_M_TEN))
+ drv_data->state = MV64XXX_I2C_STATE_SEND_ADDR_2;
+ else if (drv_data->msg->flags & I2C_M_RD)
+ drv_data->state = MV64XXX_I2C_STATE_READ;
+ else
+ drv_data->state = MV64XXX_I2C_STATE_WRITE;
break;
- /* Performing a read */
- case MV64XXX_I2C_STATUS_MAST_RD_ADDR_ACK: /* 40 */
- if (drv_data->msg->flags & I2C_M_TEN) {
- drv_data->action = MV64XXX_I2C_ACTION_SEND_ADDR_2;
- drv_data->state =
- MV64XXX_I2C_STATE_WAITING_FOR_ADDR_2_ACK;
- break;
- }
- fallthrough;
- case MV64XXX_I2C_STATUS_MAST_RD_ADDR_2_ACK: /* 0xe0 */
- if (drv_data->bytes_left == 0) {
- drv_data->action = MV64XXX_I2C_ACTION_SEND_STOP;
- drv_data->state = MV64XXX_I2C_STATE_IDLE;
- break;
- }
- fallthrough;
- case MV64XXX_I2C_STATUS_MAST_RD_DATA_ACK: /* 0x50 */
- if (status != MV64XXX_I2C_STATUS_MAST_RD_DATA_ACK)
- drv_data->action = MV64XXX_I2C_ACTION_CONTINUE;
- else {
- drv_data->action = MV64XXX_I2C_ACTION_RCV_DATA;
- drv_data->bytes_left--;
- }
- drv_data->state = MV64XXX_I2C_STATE_WAITING_FOR_SLAVE_DATA;
+ case MV64XXX_I2C_EVENT_ADDR_NO_ACK:
+ case MV64XXX_I2C_EVENT_WR_NO_ACK:
+ /* Doesn't seem to be a device at other end */
+ drv_data->state = MV64XXX_I2C_STATE_IDLE;
+ break;
- if ((drv_data->bytes_left == 1) || drv_data->aborting)
- drv_data->cntl_bits &= ~MV64XXX_I2C_REG_CONTROL_ACK;
+ case MV64XXX_I2C_EVENT_WR_ACK:
break;
- case MV64XXX_I2C_STATUS_MAST_RD_DATA_NO_ACK: /* 0x58 */
- drv_data->action = MV64XXX_I2C_ACTION_RCV_DATA_STOP;
- drv_data->state = MV64XXX_I2C_STATE_IDLE;
+ case MV64XXX_I2C_EVENT_RD_ACKED:
+ BUG_ON(drv_data->bytes_left == 0);
break;
- case MV64XXX_I2C_STATUS_MAST_WR_ADDR_NO_ACK: /* 0x20 */
- case MV64XXX_I2C_STATUS_MAST_WR_NO_ACK: /* 30 */
- case MV64XXX_I2C_STATUS_MAST_RD_ADDR_NO_ACK: /* 48 */
- /* Doesn't seem to be a device at other end */
- drv_data->action = MV64XXX_I2C_ACTION_SEND_STOP;
- drv_data->state = MV64XXX_I2C_STATE_IDLE;
- drv_data->rc = -ENXIO;
+ case MV64XXX_I2C_EVENT_RD_UNACKED:
+ BUG_ON(drv_data->bytes_left != 0);
break;
+ case MV64XXX_I2C_EVENT_INVALID:
default:
dev_err(&drv_data->adapter.dev,
"mv64xxx_i2c_fsm: Ctlr Error -- state: 0x%x, "
- "status: 0x%x, addr: 0x%x, flags: 0x%x\n",
- drv_data->state, status, drv_data->msg->addr,
+ "status: 0x%x, event: 0x%x, addr: 0x%x, flags: 0x%x\n",
+ drv_data->state, status, event, drv_data->msg->addr,
drv_data->msg->flags);
drv_data->action = MV64XXX_I2C_ACTION_SEND_STOP;
mv64xxx_i2c_hw_init(drv_data);
i2c_recover_bus(&drv_data->adapter);
drv_data->rc = -EAGAIN;
+ return;
+ }
+
+ /* Internal FSM transitions and action emission */
+ switch (drv_data->state) {
+ case MV64XXX_I2C_STATE_IDLE:
+ drv_data->action = MV64XXX_I2C_ACTION_SEND_STOP;
+ drv_data->rc = -ENXIO;
+ break;
+
+ case MV64XXX_I2C_STATE_SEND_ADDR_1:
+ drv_data->action = MV64XXX_I2C_ACTION_SEND_ADDR_1;
+ break;
+
+ case MV64XXX_I2C_STATE_SEND_ADDR_2:
+ drv_data->action = MV64XXX_I2C_ACTION_SEND_ADDR_2;
+ break;
+
+ case MV64XXX_I2C_STATE_READ:
+ if (drv_data->bytes_left == 0) {
+ if (prev_state == MV64XXX_I2C_STATE_READ)
+ drv_data->action = MV64XXX_I2C_ACTION_RCV_DATA_STOP;
+ else
+ drv_data->action = MV64XXX_I2C_ACTION_SEND_STOP;
+ drv_data->state = MV64XXX_I2C_STATE_IDLE;
+ } else {
+ if (prev_state == MV64XXX_I2C_STATE_READ)
+ drv_data->action = MV64XXX_I2C_ACTION_RCV_DATA;
+ else
+ drv_data->action = MV64XXX_I2C_ACTION_CONTINUE;
+
+ /*
+ * bytes_left counts the remaining read actions to send
+ * to the hardware, not the remaining bytes to be
+ * retrieved from the data register
+ */
+ if (drv_data->aborting)
+ drv_data->bytes_left = 0;
+ else
+ drv_data->bytes_left--;
+
+ if (drv_data->bytes_left == 0)
+ drv_data->cntl_bits &= ~MV64XXX_I2C_REG_CONTROL_ACK;
+ }
+ break;
+
+ case MV64XXX_I2C_STATE_WRITE:
+ if ((drv_data->bytes_left == 0)
+ || (drv_data->aborting && (drv_data->byte_posn != 0))) {
+ if (drv_data->send_stop || drv_data->aborting) {
+ drv_data->action = MV64XXX_I2C_ACTION_SEND_STOP;
+ drv_data->state = MV64XXX_I2C_STATE_IDLE;
+ } else {
+ drv_data->action = MV64XXX_I2C_ACTION_SEND_RESTART;
+ drv_data->state = MV64XXX_I2C_STATE_RESTART;
+ }
+ } else {
+ drv_data->action = MV64XXX_I2C_ACTION_SEND_DATA;
+ drv_data->bytes_left--;
+ }
+ break;
+
+ default:
}
}
@@ -611,7 +711,7 @@ mv64xxx_i2c_execute_msg(struct mv64xxx_i2c_data *drv_data, struct i2c_msg *msg,
spin_lock_irqsave(&drv_data->lock, flags);
- drv_data->state = MV64XXX_I2C_STATE_WAITING_FOR_START_COND;
+ drv_data->state = MV64XXX_I2C_STATE_START;
drv_data->send_stop = is_last;
drv_data->block = 1;
--
2.43.2
^ permalink raw reply related [flat|nested] 3+ messages in thread
* Re: [RESEND v2 RFC 3/5] i2c: mv64xxx: Refactor FSM
2024-03-19 22:52 [RESEND v2 RFC 3/5] i2c: mv64xxx: Refactor FSM Sam Edwards
@ 2024-03-20 20:10 ` kernel test robot
2024-03-21 3:56 ` kernel test robot
1 sibling, 0 replies; 3+ messages in thread
From: kernel test robot @ 2024-03-20 20:10 UTC (permalink / raw)
To: Sam Edwards; +Cc: llvm, oe-kbuild-all
Hi Sam,
[This is a private test report for your RFC patch.]
kernel test robot noticed the following build warnings:
[auto build test WARNING on andi-shyti/i2c/i2c-host]
[also build test WARNING on linus/master v6.8 next-20240320]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]
url: https://github.com/intel-lab-lkp/linux/commits/Sam-Edwards/i2c-mv64xxx-Clear-bus-errors-before-transfer/20240320-133733
base: git://git.kernel.org/pub/scm/linux/kernel/git/andi.shyti/linux.git i2c/i2c-host
patch link: https://lore.kernel.org/r/65fa759e.5d0a0220.fe5f7.1fa2%40mx.google.com
patch subject: [RESEND v2 RFC 3/5] i2c: mv64xxx: Refactor FSM
config: riscv-defconfig (https://download.01.org/0day-ci/archive/20240321/202403210350.eofnJoJU-lkp@intel.com/config)
compiler: clang version 19.0.0git (https://github.com/llvm/llvm-project 8f68022f8e6e54d1aeae4ed301f5a015963089b7)
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20240321/202403210350.eofnJoJU-lkp@intel.com/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@intel.com>
| Closes: https://lore.kernel.org/oe-kbuild-all/202403210350.eofnJoJU-lkp@intel.com/
All warnings (new ones prefixed by >>):
In file included from drivers/i2c/busses/i2c-mv64xxx.c:18:
In file included from include/linux/i2c.h:19:
In file included from include/linux/regulator/consumer.h:35:
In file included from include/linux/suspend.h:5:
In file included from include/linux/swap.h:9:
In file included from include/linux/memcontrol.h:13:
In file included from include/linux/cgroup.h:26:
In file included from include/linux/kernel_stat.h:9:
In file included from include/linux/interrupt.h:21:
In file included from arch/riscv/include/asm/sections.h:9:
In file included from include/linux/mm.h:2188:
include/linux/vmstat.h:522:36: warning: arithmetic between different enumeration types ('enum node_stat_item' and 'enum lru_list') [-Wenum-enum-conversion]
522 | return node_stat_name(NR_LRU_BASE + lru) + 3; // skip "nr_"
| ~~~~~~~~~~~ ^ ~~~
>> drivers/i2c/busses/i2c-mv64xxx.c:440:2: warning: label at end of compound statement is a C23 extension [-Wc23-extensions]
440 | }
| ^
2 warnings generated.
vim +440 drivers/i2c/busses/i2c-mv64xxx.c
1873c8bc09771f Sam Edwards 2024-03-19 306
^1da177e4c3f41 Linus Torvalds 2005-04-16 307 static void
^1da177e4c3f41 Linus Torvalds 2005-04-16 308 mv64xxx_i2c_fsm(struct mv64xxx_i2c_data *drv_data, u32 status)
^1da177e4c3f41 Linus Torvalds 2005-04-16 309 {
1873c8bc09771f Sam Edwards 2024-03-19 310 enum mv64xxx_i2c_event event;
1873c8bc09771f Sam Edwards 2024-03-19 311 enum mv64xxx_i2c_state prev_state = drv_data->state;
1873c8bc09771f Sam Edwards 2024-03-19 312
1873c8bc09771f Sam Edwards 2024-03-19 313 drv_data->action = MV64XXX_I2C_ACTION_INVALID;
1873c8bc09771f Sam Edwards 2024-03-19 314
^1da177e4c3f41 Linus Torvalds 2005-04-16 315 /*
^1da177e4c3f41 Linus Torvalds 2005-04-16 316 * If state is idle, then this is likely the remnants of an old
^1da177e4c3f41 Linus Torvalds 2005-04-16 317 * operation that driver has given up on or the user has killed.
^1da177e4c3f41 Linus Torvalds 2005-04-16 318 * If so, issue the stop condition and go to idle.
^1da177e4c3f41 Linus Torvalds 2005-04-16 319 */
^1da177e4c3f41 Linus Torvalds 2005-04-16 320 if (drv_data->state == MV64XXX_I2C_STATE_IDLE) {
^1da177e4c3f41 Linus Torvalds 2005-04-16 321 drv_data->action = MV64XXX_I2C_ACTION_SEND_STOP;
^1da177e4c3f41 Linus Torvalds 2005-04-16 322 return;
^1da177e4c3f41 Linus Torvalds 2005-04-16 323 }
^1da177e4c3f41 Linus Torvalds 2005-04-16 324
1873c8bc09771f Sam Edwards 2024-03-19 325 /*
1873c8bc09771f Sam Edwards 2024-03-19 326 * The FSM is broken into 3 parts:
1873c8bc09771f Sam Edwards 2024-03-19 327 * 1) Decode `status` to determine the underlying hardware event
1873c8bc09771f Sam Edwards 2024-03-19 328 * 2) Handle hardware event driven state transitions
1873c8bc09771f Sam Edwards 2024-03-19 329 * 3) Perform internal state transitions and action emission
1873c8bc09771f Sam Edwards 2024-03-19 330 */
1873c8bc09771f Sam Edwards 2024-03-19 331 event = mv64xxx_i2c_decode_status(drv_data, status);
1873c8bc09771f Sam Edwards 2024-03-19 332
1873c8bc09771f Sam Edwards 2024-03-19 333 /* Handle event; determine state transition */
1873c8bc09771f Sam Edwards 2024-03-19 334 switch (event) {
1873c8bc09771f Sam Edwards 2024-03-19 335 case MV64XXX_I2C_EVENT_STARTED:
1873c8bc09771f Sam Edwards 2024-03-19 336 drv_data->state = MV64XXX_I2C_STATE_SEND_ADDR_1;
^1da177e4c3f41 Linus Torvalds 2005-04-16 337 break;
^1da177e4c3f41 Linus Torvalds 2005-04-16 338
1873c8bc09771f Sam Edwards 2024-03-19 339 case MV64XXX_I2C_EVENT_ADDR_ACK:
1873c8bc09771f Sam Edwards 2024-03-19 340 if ((drv_data->state == MV64XXX_I2C_STATE_SEND_ADDR_1)
1873c8bc09771f Sam Edwards 2024-03-19 341 && (drv_data->msg->flags & I2C_M_TEN))
1873c8bc09771f Sam Edwards 2024-03-19 342 drv_data->state = MV64XXX_I2C_STATE_SEND_ADDR_2;
1873c8bc09771f Sam Edwards 2024-03-19 343 else if (drv_data->msg->flags & I2C_M_RD)
1873c8bc09771f Sam Edwards 2024-03-19 344 drv_data->state = MV64XXX_I2C_STATE_READ;
1873c8bc09771f Sam Edwards 2024-03-19 345 else
1873c8bc09771f Sam Edwards 2024-03-19 346 drv_data->state = MV64XXX_I2C_STATE_WRITE;
^1da177e4c3f41 Linus Torvalds 2005-04-16 347 break;
1873c8bc09771f Sam Edwards 2024-03-19 348
1873c8bc09771f Sam Edwards 2024-03-19 349 case MV64XXX_I2C_EVENT_ADDR_NO_ACK:
1873c8bc09771f Sam Edwards 2024-03-19 350 case MV64XXX_I2C_EVENT_WR_NO_ACK:
1873c8bc09771f Sam Edwards 2024-03-19 351 /* Doesn't seem to be a device at other end */
e91c021c487110 Mark A. Greer 2005-12-18 352 drv_data->state = MV64XXX_I2C_STATE_IDLE;
1873c8bc09771f Sam Edwards 2024-03-19 353 break;
1873c8bc09771f Sam Edwards 2024-03-19 354
1873c8bc09771f Sam Edwards 2024-03-19 355 case MV64XXX_I2C_EVENT_WR_ACK:
1873c8bc09771f Sam Edwards 2024-03-19 356 break;
1873c8bc09771f Sam Edwards 2024-03-19 357
1873c8bc09771f Sam Edwards 2024-03-19 358 case MV64XXX_I2C_EVENT_RD_ACKED:
1873c8bc09771f Sam Edwards 2024-03-19 359 BUG_ON(drv_data->bytes_left == 0);
1873c8bc09771f Sam Edwards 2024-03-19 360 break;
1873c8bc09771f Sam Edwards 2024-03-19 361
1873c8bc09771f Sam Edwards 2024-03-19 362 case MV64XXX_I2C_EVENT_RD_UNACKED:
1873c8bc09771f Sam Edwards 2024-03-19 363 BUG_ON(drv_data->bytes_left != 0);
1873c8bc09771f Sam Edwards 2024-03-19 364 break;
1873c8bc09771f Sam Edwards 2024-03-19 365
1873c8bc09771f Sam Edwards 2024-03-19 366 case MV64XXX_I2C_EVENT_INVALID:
1873c8bc09771f Sam Edwards 2024-03-19 367 default:
1873c8bc09771f Sam Edwards 2024-03-19 368 dev_err(&drv_data->adapter.dev,
1873c8bc09771f Sam Edwards 2024-03-19 369 "mv64xxx_i2c_fsm: Ctlr Error -- state: 0x%x, "
1873c8bc09771f Sam Edwards 2024-03-19 370 "status: 0x%x, event: 0x%x, addr: 0x%x, flags: 0x%x\n",
1873c8bc09771f Sam Edwards 2024-03-19 371 drv_data->state, status, event, drv_data->msg->addr,
1873c8bc09771f Sam Edwards 2024-03-19 372 drv_data->msg->flags);
1873c8bc09771f Sam Edwards 2024-03-19 373 drv_data->action = MV64XXX_I2C_ACTION_SEND_STOP;
1873c8bc09771f Sam Edwards 2024-03-19 374 mv64xxx_i2c_hw_init(drv_data);
1873c8bc09771f Sam Edwards 2024-03-19 375 i2c_recover_bus(&drv_data->adapter);
1873c8bc09771f Sam Edwards 2024-03-19 376 drv_data->rc = -EAGAIN;
1873c8bc09771f Sam Edwards 2024-03-19 377 return;
^1da177e4c3f41 Linus Torvalds 2005-04-16 378 }
1873c8bc09771f Sam Edwards 2024-03-19 379
1873c8bc09771f Sam Edwards 2024-03-19 380 /* Internal FSM transitions and action emission */
1873c8bc09771f Sam Edwards 2024-03-19 381 switch (drv_data->state) {
1873c8bc09771f Sam Edwards 2024-03-19 382 case MV64XXX_I2C_STATE_IDLE:
1873c8bc09771f Sam Edwards 2024-03-19 383 drv_data->action = MV64XXX_I2C_ACTION_SEND_STOP;
1873c8bc09771f Sam Edwards 2024-03-19 384 drv_data->rc = -ENXIO;
1873c8bc09771f Sam Edwards 2024-03-19 385 break;
1873c8bc09771f Sam Edwards 2024-03-19 386
1873c8bc09771f Sam Edwards 2024-03-19 387 case MV64XXX_I2C_STATE_SEND_ADDR_1:
1873c8bc09771f Sam Edwards 2024-03-19 388 drv_data->action = MV64XXX_I2C_ACTION_SEND_ADDR_1;
^1da177e4c3f41 Linus Torvalds 2005-04-16 389 break;
^1da177e4c3f41 Linus Torvalds 2005-04-16 390
1873c8bc09771f Sam Edwards 2024-03-19 391 case MV64XXX_I2C_STATE_SEND_ADDR_2:
^1da177e4c3f41 Linus Torvalds 2005-04-16 392 drv_data->action = MV64XXX_I2C_ACTION_SEND_ADDR_2;
^1da177e4c3f41 Linus Torvalds 2005-04-16 393 break;
1873c8bc09771f Sam Edwards 2024-03-19 394
1873c8bc09771f Sam Edwards 2024-03-19 395 case MV64XXX_I2C_STATE_READ:
^1da177e4c3f41 Linus Torvalds 2005-04-16 396 if (drv_data->bytes_left == 0) {
1873c8bc09771f Sam Edwards 2024-03-19 397 if (prev_state == MV64XXX_I2C_STATE_READ)
1873c8bc09771f Sam Edwards 2024-03-19 398 drv_data->action = MV64XXX_I2C_ACTION_RCV_DATA_STOP;
1873c8bc09771f Sam Edwards 2024-03-19 399 else
^1da177e4c3f41 Linus Torvalds 2005-04-16 400 drv_data->action = MV64XXX_I2C_ACTION_SEND_STOP;
^1da177e4c3f41 Linus Torvalds 2005-04-16 401 drv_data->state = MV64XXX_I2C_STATE_IDLE;
1873c8bc09771f Sam Edwards 2024-03-19 402 } else {
1873c8bc09771f Sam Edwards 2024-03-19 403 if (prev_state == MV64XXX_I2C_STATE_READ)
^1da177e4c3f41 Linus Torvalds 2005-04-16 404 drv_data->action = MV64XXX_I2C_ACTION_RCV_DATA;
1873c8bc09771f Sam Edwards 2024-03-19 405 else
1873c8bc09771f Sam Edwards 2024-03-19 406 drv_data->action = MV64XXX_I2C_ACTION_CONTINUE;
1873c8bc09771f Sam Edwards 2024-03-19 407
1873c8bc09771f Sam Edwards 2024-03-19 408 /*
1873c8bc09771f Sam Edwards 2024-03-19 409 * bytes_left counts the remaining read actions to send
1873c8bc09771f Sam Edwards 2024-03-19 410 * to the hardware, not the remaining bytes to be
1873c8bc09771f Sam Edwards 2024-03-19 411 * retrieved from the data register
1873c8bc09771f Sam Edwards 2024-03-19 412 */
1873c8bc09771f Sam Edwards 2024-03-19 413 if (drv_data->aborting)
1873c8bc09771f Sam Edwards 2024-03-19 414 drv_data->bytes_left = 0;
1873c8bc09771f Sam Edwards 2024-03-19 415 else
^1da177e4c3f41 Linus Torvalds 2005-04-16 416 drv_data->bytes_left--;
^1da177e4c3f41 Linus Torvalds 2005-04-16 417
1873c8bc09771f Sam Edwards 2024-03-19 418 if (drv_data->bytes_left == 0)
^1da177e4c3f41 Linus Torvalds 2005-04-16 419 drv_data->cntl_bits &= ~MV64XXX_I2C_REG_CONTROL_ACK;
1873c8bc09771f Sam Edwards 2024-03-19 420 }
^1da177e4c3f41 Linus Torvalds 2005-04-16 421 break;
^1da177e4c3f41 Linus Torvalds 2005-04-16 422
1873c8bc09771f Sam Edwards 2024-03-19 423 case MV64XXX_I2C_STATE_WRITE:
1873c8bc09771f Sam Edwards 2024-03-19 424 if ((drv_data->bytes_left == 0)
1873c8bc09771f Sam Edwards 2024-03-19 425 || (drv_data->aborting && (drv_data->byte_posn != 0))) {
1873c8bc09771f Sam Edwards 2024-03-19 426 if (drv_data->send_stop || drv_data->aborting) {
^1da177e4c3f41 Linus Torvalds 2005-04-16 427 drv_data->action = MV64XXX_I2C_ACTION_SEND_STOP;
^1da177e4c3f41 Linus Torvalds 2005-04-16 428 drv_data->state = MV64XXX_I2C_STATE_IDLE;
1873c8bc09771f Sam Edwards 2024-03-19 429 } else {
1873c8bc09771f Sam Edwards 2024-03-19 430 drv_data->action = MV64XXX_I2C_ACTION_SEND_RESTART;
1873c8bc09771f Sam Edwards 2024-03-19 431 drv_data->state = MV64XXX_I2C_STATE_RESTART;
1873c8bc09771f Sam Edwards 2024-03-19 432 }
1873c8bc09771f Sam Edwards 2024-03-19 433 } else {
1873c8bc09771f Sam Edwards 2024-03-19 434 drv_data->action = MV64XXX_I2C_ACTION_SEND_DATA;
1873c8bc09771f Sam Edwards 2024-03-19 435 drv_data->bytes_left--;
1873c8bc09771f Sam Edwards 2024-03-19 436 }
^1da177e4c3f41 Linus Torvalds 2005-04-16 437 break;
^1da177e4c3f41 Linus Torvalds 2005-04-16 438
^1da177e4c3f41 Linus Torvalds 2005-04-16 439 default:
^1da177e4c3f41 Linus Torvalds 2005-04-16 @440 }
^1da177e4c3f41 Linus Torvalds 2005-04-16 441 }
^1da177e4c3f41 Linus Torvalds 2005-04-16 442
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
^ permalink raw reply [flat|nested] 3+ messages in thread
* Re: [RESEND v2 RFC 3/5] i2c: mv64xxx: Refactor FSM
2024-03-19 22:52 [RESEND v2 RFC 3/5] i2c: mv64xxx: Refactor FSM Sam Edwards
2024-03-20 20:10 ` kernel test robot
@ 2024-03-21 3:56 ` kernel test robot
1 sibling, 0 replies; 3+ messages in thread
From: kernel test robot @ 2024-03-21 3:56 UTC (permalink / raw)
To: Sam Edwards; +Cc: llvm, oe-kbuild-all
Hi Sam,
[This is a private test report for your RFC patch.]
kernel test robot noticed the following build errors:
[auto build test ERROR on andi-shyti/i2c/i2c-host]
[also build test ERROR on linus/master v6.8 next-20240320]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]
url: https://github.com/intel-lab-lkp/linux/commits/Sam-Edwards/i2c-mv64xxx-Clear-bus-errors-before-transfer/20240320-133733
base: git://git.kernel.org/pub/scm/linux/kernel/git/andi.shyti/linux.git i2c/i2c-host
patch link: https://lore.kernel.org/r/65fa759e.5d0a0220.fe5f7.1fa2%40mx.google.com
patch subject: [RESEND v2 RFC 3/5] i2c: mv64xxx: Refactor FSM
config: arm-defconfig (https://download.01.org/0day-ci/archive/20240321/202403211142.qpQXb5FQ-lkp@intel.com/config)
compiler: clang version 14.0.6 (https://github.com/llvm/llvm-project.git f28c006a5895fc0e329fe15fead81e37457cb1d1)
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20240321/202403211142.qpQXb5FQ-lkp@intel.com/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@intel.com>
| Closes: https://lore.kernel.org/oe-kbuild-all/202403211142.qpQXb5FQ-lkp@intel.com/
All errors (new ones prefixed by >>):
>> drivers/i2c/busses/i2c-mv64xxx.c:439:10: error: label at end of compound statement: expected statement
default:
^
;
1 error generated.
vim +439 drivers/i2c/busses/i2c-mv64xxx.c
1873c8bc09771f Sam Edwards 2024-03-19 306
^1da177e4c3f41 Linus Torvalds 2005-04-16 307 static void
^1da177e4c3f41 Linus Torvalds 2005-04-16 308 mv64xxx_i2c_fsm(struct mv64xxx_i2c_data *drv_data, u32 status)
^1da177e4c3f41 Linus Torvalds 2005-04-16 309 {
1873c8bc09771f Sam Edwards 2024-03-19 310 enum mv64xxx_i2c_event event;
1873c8bc09771f Sam Edwards 2024-03-19 311 enum mv64xxx_i2c_state prev_state = drv_data->state;
1873c8bc09771f Sam Edwards 2024-03-19 312
1873c8bc09771f Sam Edwards 2024-03-19 313 drv_data->action = MV64XXX_I2C_ACTION_INVALID;
1873c8bc09771f Sam Edwards 2024-03-19 314
^1da177e4c3f41 Linus Torvalds 2005-04-16 315 /*
^1da177e4c3f41 Linus Torvalds 2005-04-16 316 * If state is idle, then this is likely the remnants of an old
^1da177e4c3f41 Linus Torvalds 2005-04-16 317 * operation that driver has given up on or the user has killed.
^1da177e4c3f41 Linus Torvalds 2005-04-16 318 * If so, issue the stop condition and go to idle.
^1da177e4c3f41 Linus Torvalds 2005-04-16 319 */
^1da177e4c3f41 Linus Torvalds 2005-04-16 320 if (drv_data->state == MV64XXX_I2C_STATE_IDLE) {
^1da177e4c3f41 Linus Torvalds 2005-04-16 321 drv_data->action = MV64XXX_I2C_ACTION_SEND_STOP;
^1da177e4c3f41 Linus Torvalds 2005-04-16 322 return;
^1da177e4c3f41 Linus Torvalds 2005-04-16 323 }
^1da177e4c3f41 Linus Torvalds 2005-04-16 324
1873c8bc09771f Sam Edwards 2024-03-19 325 /*
1873c8bc09771f Sam Edwards 2024-03-19 326 * The FSM is broken into 3 parts:
1873c8bc09771f Sam Edwards 2024-03-19 327 * 1) Decode `status` to determine the underlying hardware event
1873c8bc09771f Sam Edwards 2024-03-19 328 * 2) Handle hardware event driven state transitions
1873c8bc09771f Sam Edwards 2024-03-19 329 * 3) Perform internal state transitions and action emission
1873c8bc09771f Sam Edwards 2024-03-19 330 */
1873c8bc09771f Sam Edwards 2024-03-19 331 event = mv64xxx_i2c_decode_status(drv_data, status);
1873c8bc09771f Sam Edwards 2024-03-19 332
1873c8bc09771f Sam Edwards 2024-03-19 333 /* Handle event; determine state transition */
1873c8bc09771f Sam Edwards 2024-03-19 334 switch (event) {
1873c8bc09771f Sam Edwards 2024-03-19 335 case MV64XXX_I2C_EVENT_STARTED:
1873c8bc09771f Sam Edwards 2024-03-19 336 drv_data->state = MV64XXX_I2C_STATE_SEND_ADDR_1;
^1da177e4c3f41 Linus Torvalds 2005-04-16 337 break;
^1da177e4c3f41 Linus Torvalds 2005-04-16 338
1873c8bc09771f Sam Edwards 2024-03-19 339 case MV64XXX_I2C_EVENT_ADDR_ACK:
1873c8bc09771f Sam Edwards 2024-03-19 340 if ((drv_data->state == MV64XXX_I2C_STATE_SEND_ADDR_1)
1873c8bc09771f Sam Edwards 2024-03-19 341 && (drv_data->msg->flags & I2C_M_TEN))
1873c8bc09771f Sam Edwards 2024-03-19 342 drv_data->state = MV64XXX_I2C_STATE_SEND_ADDR_2;
1873c8bc09771f Sam Edwards 2024-03-19 343 else if (drv_data->msg->flags & I2C_M_RD)
1873c8bc09771f Sam Edwards 2024-03-19 344 drv_data->state = MV64XXX_I2C_STATE_READ;
1873c8bc09771f Sam Edwards 2024-03-19 345 else
1873c8bc09771f Sam Edwards 2024-03-19 346 drv_data->state = MV64XXX_I2C_STATE_WRITE;
^1da177e4c3f41 Linus Torvalds 2005-04-16 347 break;
1873c8bc09771f Sam Edwards 2024-03-19 348
1873c8bc09771f Sam Edwards 2024-03-19 349 case MV64XXX_I2C_EVENT_ADDR_NO_ACK:
1873c8bc09771f Sam Edwards 2024-03-19 350 case MV64XXX_I2C_EVENT_WR_NO_ACK:
1873c8bc09771f Sam Edwards 2024-03-19 351 /* Doesn't seem to be a device at other end */
e91c021c487110 Mark A. Greer 2005-12-18 352 drv_data->state = MV64XXX_I2C_STATE_IDLE;
1873c8bc09771f Sam Edwards 2024-03-19 353 break;
1873c8bc09771f Sam Edwards 2024-03-19 354
1873c8bc09771f Sam Edwards 2024-03-19 355 case MV64XXX_I2C_EVENT_WR_ACK:
1873c8bc09771f Sam Edwards 2024-03-19 356 break;
1873c8bc09771f Sam Edwards 2024-03-19 357
1873c8bc09771f Sam Edwards 2024-03-19 358 case MV64XXX_I2C_EVENT_RD_ACKED:
1873c8bc09771f Sam Edwards 2024-03-19 359 BUG_ON(drv_data->bytes_left == 0);
1873c8bc09771f Sam Edwards 2024-03-19 360 break;
1873c8bc09771f Sam Edwards 2024-03-19 361
1873c8bc09771f Sam Edwards 2024-03-19 362 case MV64XXX_I2C_EVENT_RD_UNACKED:
1873c8bc09771f Sam Edwards 2024-03-19 363 BUG_ON(drv_data->bytes_left != 0);
1873c8bc09771f Sam Edwards 2024-03-19 364 break;
1873c8bc09771f Sam Edwards 2024-03-19 365
1873c8bc09771f Sam Edwards 2024-03-19 366 case MV64XXX_I2C_EVENT_INVALID:
1873c8bc09771f Sam Edwards 2024-03-19 367 default:
1873c8bc09771f Sam Edwards 2024-03-19 368 dev_err(&drv_data->adapter.dev,
1873c8bc09771f Sam Edwards 2024-03-19 369 "mv64xxx_i2c_fsm: Ctlr Error -- state: 0x%x, "
1873c8bc09771f Sam Edwards 2024-03-19 370 "status: 0x%x, event: 0x%x, addr: 0x%x, flags: 0x%x\n",
1873c8bc09771f Sam Edwards 2024-03-19 371 drv_data->state, status, event, drv_data->msg->addr,
1873c8bc09771f Sam Edwards 2024-03-19 372 drv_data->msg->flags);
1873c8bc09771f Sam Edwards 2024-03-19 373 drv_data->action = MV64XXX_I2C_ACTION_SEND_STOP;
1873c8bc09771f Sam Edwards 2024-03-19 374 mv64xxx_i2c_hw_init(drv_data);
1873c8bc09771f Sam Edwards 2024-03-19 375 i2c_recover_bus(&drv_data->adapter);
1873c8bc09771f Sam Edwards 2024-03-19 376 drv_data->rc = -EAGAIN;
1873c8bc09771f Sam Edwards 2024-03-19 377 return;
^1da177e4c3f41 Linus Torvalds 2005-04-16 378 }
1873c8bc09771f Sam Edwards 2024-03-19 379
1873c8bc09771f Sam Edwards 2024-03-19 380 /* Internal FSM transitions and action emission */
1873c8bc09771f Sam Edwards 2024-03-19 381 switch (drv_data->state) {
1873c8bc09771f Sam Edwards 2024-03-19 382 case MV64XXX_I2C_STATE_IDLE:
1873c8bc09771f Sam Edwards 2024-03-19 383 drv_data->action = MV64XXX_I2C_ACTION_SEND_STOP;
1873c8bc09771f Sam Edwards 2024-03-19 384 drv_data->rc = -ENXIO;
1873c8bc09771f Sam Edwards 2024-03-19 385 break;
1873c8bc09771f Sam Edwards 2024-03-19 386
1873c8bc09771f Sam Edwards 2024-03-19 387 case MV64XXX_I2C_STATE_SEND_ADDR_1:
1873c8bc09771f Sam Edwards 2024-03-19 388 drv_data->action = MV64XXX_I2C_ACTION_SEND_ADDR_1;
^1da177e4c3f41 Linus Torvalds 2005-04-16 389 break;
^1da177e4c3f41 Linus Torvalds 2005-04-16 390
1873c8bc09771f Sam Edwards 2024-03-19 391 case MV64XXX_I2C_STATE_SEND_ADDR_2:
^1da177e4c3f41 Linus Torvalds 2005-04-16 392 drv_data->action = MV64XXX_I2C_ACTION_SEND_ADDR_2;
^1da177e4c3f41 Linus Torvalds 2005-04-16 393 break;
1873c8bc09771f Sam Edwards 2024-03-19 394
1873c8bc09771f Sam Edwards 2024-03-19 395 case MV64XXX_I2C_STATE_READ:
^1da177e4c3f41 Linus Torvalds 2005-04-16 396 if (drv_data->bytes_left == 0) {
1873c8bc09771f Sam Edwards 2024-03-19 397 if (prev_state == MV64XXX_I2C_STATE_READ)
1873c8bc09771f Sam Edwards 2024-03-19 398 drv_data->action = MV64XXX_I2C_ACTION_RCV_DATA_STOP;
1873c8bc09771f Sam Edwards 2024-03-19 399 else
^1da177e4c3f41 Linus Torvalds 2005-04-16 400 drv_data->action = MV64XXX_I2C_ACTION_SEND_STOP;
^1da177e4c3f41 Linus Torvalds 2005-04-16 401 drv_data->state = MV64XXX_I2C_STATE_IDLE;
1873c8bc09771f Sam Edwards 2024-03-19 402 } else {
1873c8bc09771f Sam Edwards 2024-03-19 403 if (prev_state == MV64XXX_I2C_STATE_READ)
^1da177e4c3f41 Linus Torvalds 2005-04-16 404 drv_data->action = MV64XXX_I2C_ACTION_RCV_DATA;
1873c8bc09771f Sam Edwards 2024-03-19 405 else
1873c8bc09771f Sam Edwards 2024-03-19 406 drv_data->action = MV64XXX_I2C_ACTION_CONTINUE;
1873c8bc09771f Sam Edwards 2024-03-19 407
1873c8bc09771f Sam Edwards 2024-03-19 408 /*
1873c8bc09771f Sam Edwards 2024-03-19 409 * bytes_left counts the remaining read actions to send
1873c8bc09771f Sam Edwards 2024-03-19 410 * to the hardware, not the remaining bytes to be
1873c8bc09771f Sam Edwards 2024-03-19 411 * retrieved from the data register
1873c8bc09771f Sam Edwards 2024-03-19 412 */
1873c8bc09771f Sam Edwards 2024-03-19 413 if (drv_data->aborting)
1873c8bc09771f Sam Edwards 2024-03-19 414 drv_data->bytes_left = 0;
1873c8bc09771f Sam Edwards 2024-03-19 415 else
^1da177e4c3f41 Linus Torvalds 2005-04-16 416 drv_data->bytes_left--;
^1da177e4c3f41 Linus Torvalds 2005-04-16 417
1873c8bc09771f Sam Edwards 2024-03-19 418 if (drv_data->bytes_left == 0)
^1da177e4c3f41 Linus Torvalds 2005-04-16 419 drv_data->cntl_bits &= ~MV64XXX_I2C_REG_CONTROL_ACK;
1873c8bc09771f Sam Edwards 2024-03-19 420 }
^1da177e4c3f41 Linus Torvalds 2005-04-16 421 break;
^1da177e4c3f41 Linus Torvalds 2005-04-16 422
1873c8bc09771f Sam Edwards 2024-03-19 423 case MV64XXX_I2C_STATE_WRITE:
1873c8bc09771f Sam Edwards 2024-03-19 424 if ((drv_data->bytes_left == 0)
1873c8bc09771f Sam Edwards 2024-03-19 425 || (drv_data->aborting && (drv_data->byte_posn != 0))) {
1873c8bc09771f Sam Edwards 2024-03-19 426 if (drv_data->send_stop || drv_data->aborting) {
^1da177e4c3f41 Linus Torvalds 2005-04-16 427 drv_data->action = MV64XXX_I2C_ACTION_SEND_STOP;
^1da177e4c3f41 Linus Torvalds 2005-04-16 428 drv_data->state = MV64XXX_I2C_STATE_IDLE;
1873c8bc09771f Sam Edwards 2024-03-19 429 } else {
1873c8bc09771f Sam Edwards 2024-03-19 430 drv_data->action = MV64XXX_I2C_ACTION_SEND_RESTART;
1873c8bc09771f Sam Edwards 2024-03-19 431 drv_data->state = MV64XXX_I2C_STATE_RESTART;
1873c8bc09771f Sam Edwards 2024-03-19 432 }
1873c8bc09771f Sam Edwards 2024-03-19 433 } else {
1873c8bc09771f Sam Edwards 2024-03-19 434 drv_data->action = MV64XXX_I2C_ACTION_SEND_DATA;
1873c8bc09771f Sam Edwards 2024-03-19 435 drv_data->bytes_left--;
1873c8bc09771f Sam Edwards 2024-03-19 436 }
^1da177e4c3f41 Linus Torvalds 2005-04-16 437 break;
^1da177e4c3f41 Linus Torvalds 2005-04-16 438
^1da177e4c3f41 Linus Torvalds 2005-04-16 @439 default:
^1da177e4c3f41 Linus Torvalds 2005-04-16 440 }
^1da177e4c3f41 Linus Torvalds 2005-04-16 441 }
^1da177e4c3f41 Linus Torvalds 2005-04-16 442
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
^ permalink raw reply [flat|nested] 3+ messages in thread
end of thread, other threads:[~2024-03-21 3:56 UTC | newest]
Thread overview: 3+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2024-03-19 22:52 [RESEND v2 RFC 3/5] i2c: mv64xxx: Refactor FSM Sam Edwards
2024-03-20 20:10 ` kernel test robot
2024-03-21 3:56 ` kernel test robot
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.