[ot] hw/opentitan: ot_i2c_transport: initial implementation

Initial implementation.

See top comment on description of the wire protocol.

Signed-off-by: Alice Ziuziakowska <[email protected]>

Author: ziuziakowska

hw/opentitan/ot_i2c_transport.c

@@ -25,35 +25,240 @@
  * THE SOFTWARE.
  */
 
+/*
+ * This device provides a method of performing I2C transactions with bus
+ * devices in QEMU through an external chardev interface.
+ * The device can issue read or write transactions to devices on the bus.
+ * This is intended to be used by OpenTitanTool, but can be driven manually
+ * for example with `netcat`.
+ *
+ * The protocol for issuing commands is as follows:
+ *
+ * - A write command begins with 'W', followed by an address byte to select the
+ *   target device. All subsequent bytes are payload bytes to be sent to the
+ *   device.
+ *
+ * - A read command begins with 'R', followed by an address byte to select the
+ *   target device. A byte is read and written back for every subsequent 'B'
+ *   byte.
+ *
+ * - All bytes values are encoded as a pair of case-insensitive ASCII hex
+ *   digits.
+ *
+ * - End of a command is indicated with an 'S', this ends the transaction.
+ *
+ * - For both commands, the address byte chosen will be echoed back if a device
+ *   with that address is found, otherwise '!!' will be sent.
+ *
+ * - For write commands, a written byte will be echoed back on ACK, otherwise
+ *   '!!' will be sent back on NACK.
+ *
+ * - Spaces and newlines in a sent command may appear anywhere except between
+ *   the pair of hex digits making up a byte, and are ignored. Unexpected
+ *   characters anywhere in a command will cause the current command to end and
+ *   command parser restarted.
+ *
+ * - There are no timing restrictions on the protocol. It is recommended to
+ *   buffer read commands to the OT I2C target device to allow OT software to
+ *   fill its FIFO with response data. Readiness of response should be
+ *   indicated via another mechanism. There is no requirement to do this for
+ *   other QEMU I2C devices.
+ *
+ * Examples:
+ *
+ * - Writing bytes 0xAB, 0xCD, 0xEF, to a device with address 0x51:
+ *
+ *      W 51 ab cd ef S
+ *
+ *   With the following output if the device exists and acknowledged all bytes:
+ *
+ *      51abcdef (address byte, followed by echoed payload data)
+ *
+ * - Reading 4 bytes from the device with address 0x51:
+ *
+ *      R 51 B B B B S
+ *
+ *   With the following example output from the device if the device exists:
+ *
+ *      51aabbccdd (address byte, followed by example read output)
+ */
+
 #include "qemu/osdep.h"
+#include "qemu/fifo8.h"
 #include "qemu/typedefs.h"
 #include "qom/object.h"
 #include "chardev/char-fe.h"
 #include "hw/i2c/i2c.h"
 #include "hw/qdev-properties-system.h"
 #include "hw/qdev-properties.h"
+#include "trace.h"
 
 #define TYPE_OT_I2C_TRANSPORT "ot-i2c-transport"
 OBJECT_DECLARE_SIMPLE_TYPE(OtI2CTransportState, OT_I2C_TRANSPORT)
 
+#define CMD_FIFO_SIZE 256u
+
+enum i2c_cmd_parser_state {
+    OT_I2C_CMD_INIT,
+    OT_I2C_CMD_ADDR_1,
+    OT_I2C_CMD_ADDR_2,
+    OT_I2C_CMD_PAYLOAD_1,
+    OT_I2C_CMD_PAYLOAD_2,
+    OT_I2C_CMD_BYTE,
+};
+
 struct OtI2CTransportState {
     I2CSlave parent_obj;
 
+    Fifo8 cmd_bytes_fifo;
+    enum i2c_cmd_parser_state parser_state;
+    bool is_read_command;
+    uint8_t byte;
+
     I2CBus *bus;
     CharBackend chr;
 };
 
+static void ot_i2c_transport_put_send_failure(OtI2CTransportState *s)
+{
+    uint8_t fmt_byte[2] = { '!', '!' };
+    qemu_chr_fe_write(&s->chr, fmt_byte, ARRAY_SIZE(fmt_byte));
+}
+
+static void
+ot_i2c_transport_put_formatted_byte(OtI2CTransportState *s, uint8_t data)
+{
+    char hex[16] = "0123456789ABCDEF";
+    uint8_t fmt_byte[2] = { hex[data >> 4u], hex[data & 0xfu] };
+    qemu_chr_fe_write(&s->chr, fmt_byte, ARRAY_SIZE(fmt_byte));
+}
+
+static void ot_i2c_transport_start_transfer(OtI2CTransportState *s)
+{
+    if (i2c_start_transfer(s->bus, s->byte, s->is_read_command) != 0) {
+        ot_i2c_transport_put_send_failure(s);
+    } else {
+        ot_i2c_transport_put_formatted_byte(s, s->byte);
+    }
+}
+
+static void ot_i2c_transport_do_read(OtI2CTransportState *s)
+{
+    ot_i2c_transport_put_formatted_byte(s, i2c_recv(s->bus));
+}
+
+static void ot_i2c_transport_do_write(OtI2CTransportState *s)
+{
+    if (i2c_send(s->bus, s->byte) != 0) {
+        ot_i2c_transport_put_send_failure(s);
+    } else {
+        ot_i2c_transport_put_formatted_byte(s, s->byte);
+    }
+}
+
+static void ot_i2c_transport_command_byte(OtI2CTransportState *s, uint8_t byte)
+{
+    int nibble;
+    switch (s->parser_state) {
+    case OT_I2C_CMD_INIT:
+        // parse either a R or W for a read or write command
+        if (byte != 'R' && byte != 'W') {
+            break;
+        }
+        s->is_read_command = byte == 'R';
+        s->byte = 0u;
+        s->parser_state = OT_I2C_CMD_ADDR_1;
+        break;
+    case OT_I2C_CMD_ADDR_1:
+        // parse first nibble of address byte
+        if (byte == '\n' || byte == ' ') {
+            break;
+        }
+        nibble = g_ascii_xdigit_value(byte);
+        if (nibble < 0) {
+            s->parser_state = OT_I2C_CMD_INIT;
+            break;
+        }
+        s->byte = (uint8_t)nibble;
+        s->parser_state = OT_I2C_CMD_ADDR_2;
+        break;
+    case OT_I2C_CMD_ADDR_2:
+        // parse second nibble of address byte
+        nibble = g_ascii_xdigit_value(byte);
+        if (nibble < 0) {
+            s->parser_state = OT_I2C_CMD_INIT;
+            break;
+        }
+        s->byte = (s->byte << 4u) | nibble;
+        ot_i2c_transport_start_transfer(s);
+        s->parser_state =
+            s->is_read_command ? OT_I2C_CMD_BYTE : OT_I2C_CMD_PAYLOAD_1;
+        break;
+    case OT_I2C_CMD_PAYLOAD_1:
+        // parse first nibble of write payload byte
+        if (byte == '\n' || byte == ' ') {
+            break;
+        }
+        // signal no more bytes to write with an S
+        if (byte == 'S') {
+            s->parser_state = OT_I2C_CMD_INIT;
+            i2c_end_transfer(s->bus);
+            break;
+        }
+        nibble = g_ascii_xdigit_value(byte);
+        if (nibble < 0) {
+            s->parser_state = OT_I2C_CMD_INIT;
+            i2c_end_transfer(s->bus);
+            break;
+        }
+        s->byte = (uint8_t)nibble;
+        s->parser_state = OT_I2C_CMD_PAYLOAD_2;
+        break;
+    case OT_I2C_CMD_PAYLOAD_2:
+        // parse second nibble of write payload byte
+        nibble = g_ascii_xdigit_value(byte);
+        if (nibble < 0) {
+            s->parser_state = OT_I2C_CMD_INIT;
+            i2c_end_transfer(s->bus);
+            break;
+        }
+        s->byte = (s->byte << 4u) | nibble;
+        ot_i2c_transport_do_write(s);
+        s->parser_state = OT_I2C_CMD_PAYLOAD_1;
+        break;
+    case OT_I2C_CMD_BYTE:
+        // parse a B to read a byte from the I2C bus
+        if (byte == '\n' || byte == ' ') {
+            break;
+        }
+        if (byte == 'B') {
+            ot_i2c_transport_do_read(s);
+            s->parser_state = OT_I2C_CMD_BYTE;
+        } else {
+            i2c_end_transfer(s->bus);
+            s->parser_state = OT_I2C_CMD_INIT;
+        }
+        break;
+    }
+}
+
 static int ot_i2c_transport_can_receive(void *opaque)
 {
-    (void)opaque;
-    return 1;
+    OtI2CTransportState *s = OT_I2C_TRANSPORT(opaque);
+    return fifo8_num_free(&s->cmd_bytes_fifo);
 }
 
 static void ot_i2c_transport_receive(void *opaque, const uint8_t *buf, int size)
 {
-    (void)opaque;
-    (void)buf;
-    (void)size;
+    OtI2CTransportState *s = OT_I2C_TRANSPORT(opaque);
+    g_assert(fifo8_num_free(&s->cmd_bytes_fifo) >= size);
+    fifo8_push_all(&s->cmd_bytes_fifo, buf, size);
+
+    // Drive the command state machine with each byte
+    while (!fifo8_is_empty(&s->cmd_bytes_fifo)) {
+        uint8_t byte = fifo8_pop(&s->cmd_bytes_fifo);
+        ot_i2c_transport_command_byte(s, byte);
+    }
 }
 
 static void ot_i2c_transport_realize(DeviceState *dev, Error **errp)
@@ -69,7 +274,10 @@ static void ot_i2c_transport_realize(DeviceState *dev, Error **errp)
 static void ot_i2c_transport_init(Object *obj)
 {
     OtI2CTransportState *s = OT_I2C_TRANSPORT(obj);
-    (void)s;
+    fifo8_create(&s->cmd_bytes_fifo, CMD_FIFO_SIZE);
+    s->parser_state = OT_I2C_CMD_INIT;
+    s->is_read_command = false;
+    s->byte = 0u;
 }
 
 static Property ot_i2c_transport_properties[] = {