extmod/machine_i2c_target: Improve events, add memaddr() getter.

Signed-off-by: Damien George <[email protected]>

Author: dpgeorge

extmod/machine_i2c_target.c

@@ -32,28 +32,33 @@
 #include "shared/runtime/mpirq.h"
 
 enum {
-    I2C_TARGET_IRQ_ADDR_MATCH = 1 << 0,
-    I2C_TARGET_IRQ_READ_REQ = 1 << 1,
-    I2C_TARGET_IRQ_WRITE_REQ = 1 << 2,
-    I2C_TARGET_IRQ_END = 1 << 3,
-    I2C_TARGET_IRQ_STOP = 1 << 4, // should be able to support this on all targets (rp2 needs custom code though), but maybe can't support addr_match?
-
-    I2C_TARGET_IRQ_MEM_ADDR_MATCH = 1 << 5, // needed?
-    I2C_TARGET_IRQ_READ_START = 1 << 6, // needed?
-    I2C_TARGET_IRQ_WRITE_START = 1 << 7, // needed?
-    I2C_TARGET_IRQ_READ_END = 1 << 8, // needed?
-    I2C_TARGET_IRQ_WRITE_END = 1 << 9, // needed?
+    // Events exposed to Python.
+    I2C_TARGET_IRQ_ADDR_MATCH_READ = 1 << 0,
+    I2C_TARGET_IRQ_ADDR_MATCH_WRITE = 1 << 1,
+    I2C_TARGET_IRQ_READ_REQ = 1 << 2,
+    I2C_TARGET_IRQ_WRITE_REQ = 1 << 3,
+    I2C_TARGET_IRQ_END_READ = 1 << 4,
+    I2C_TARGET_IRQ_END_WRITE = 1 << 5,
+
+    // Internal events, not exposed to Python.
+    I2C_TARGET_IRQ_STOP = 1 << 6,
+    I2C_TARGET_IRQ_MEM_ADDR_MATCH = 1 << 7,
+    I2C_TARGET_IRQ_READ_START = 1 << 8,
+    I2C_TARGET_IRQ_WRITE_START = 1 << 9,
 };
 
-/*
-mp_machine_i2c_target_event_addr_match(*, read_write)
-mp_machine_i2c_target_event_read_req(*)
-mp_machine_i2c_target_event_write_req(*)
-mp_machine_i2c_target_event_stop(*)
-*/
+// Define the IRQs that require a hard interrupt.
+#define I2C_TARGET_IRQ_ALL_HARD ( \
+        I2C_TARGET_IRQ_ADDR_MATCH_READ \
+        | I2C_TARGET_IRQ_ADDR_MATCH_WRITE \
+        | I2C_TARGET_IRQ_READ_REQ \
+        | I2C_TARGET_IRQ_WRITE_REQ \
+    )
 
 enum {
     STATE_IDLE,
+    STATE_ADDR_MATCH_READ,
+    STATE_ADDR_MATCH_WRITE,
     STATE_MEM_ADDR_SELECT,
     STATE_READING,
     STATE_WRITING,
@@ -63,6 +68,7 @@ typedef struct _machine_i2c_target_data_t {
     uint8_t state;
     uint8_t mem_addr_count;
     uint8_t mem_addrsize;
+    uint32_t mem_addr_last;
     uint32_t mem_addr;
     uint32_t mem_len;
     uint8_t *mem_buf;
@@ -96,23 +102,26 @@ static void mp_machine_i2c_target_deinit(machine_i2c_target_obj_t *self);
 
 static const mp_irq_methods_t machine_i2c_target_irq_methods;
 
-#define I2C_TARGET_NUM_IRQ (4)
+static machine_i2c_target_data_t machine_i2c_target_data[MICROPY_PY_MACHINE_I2C_TARGET_MAX];
 
 // Needed to retain a root pointer to the memory object.
-MP_REGISTER_ROOT_POINTER(mp_obj_t i2c_target_mem_obj[I2C_TARGET_NUM_IRQ]);
+MP_REGISTER_ROOT_POINTER(mp_obj_t machine_i2c_target_mem_obj[MICROPY_PY_MACHINE_I2C_TARGET_MAX]);
 
-MP_REGISTER_ROOT_POINTER(void *machine_i2c_target_irq_obj[I2C_TARGET_NUM_IRQ]);
+MP_REGISTER_ROOT_POINTER(void *machine_i2c_target_irq_obj[MICROPY_PY_MACHINE_I2C_TARGET_MAX]);
 
 void mp_machine_i2c_target_deinit_all(void) {
-    for (size_t i = 0; i < I2C_TARGET_NUM_IRQ; ++i) {
-        MP_STATE_PORT(i2c_target_mem_obj[i]) = MP_OBJ_NULL;
+    for (size_t i = 0; i < MICROPY_PY_MACHINE_I2C_TARGET_MAX; ++i) {
+        MP_STATE_PORT(machine_i2c_target_mem_obj[i]) = MP_OBJ_NULL;
         MP_STATE_PORT(machine_i2c_target_irq_obj[i]) = NULL;
     }
     mp_machine_i2c_target_deinit_all_port();
 }
 
-static bool event(machine_i2c_target_data_t *data, unsigned int trigger, size_t arg0, size_t arg1) {
-    unsigned int id = 0; // TODO
+static bool handle_event(machine_i2c_target_data_t *data, unsigned int trigger) {
+    unsigned int id = data - &machine_i2c_target_data[0];
+    if (trigger & I2C_TARGET_IRQ_MEM_ADDR_MATCH) {
+        data->mem_addr_last = data->mem_addr;
+    }
     machine_i2c_target_irq_obj_t *irq = MP_STATE_PORT(machine_i2c_target_irq_obj[id]);
     if (irq != NULL && (trigger & irq->trigger)) {
         irq->flags = trigger & irq->trigger;
@@ -126,6 +135,7 @@ static void machine_i2c_target_data_init(machine_i2c_target_data_t *data, mp_obj
     data->state = STATE_IDLE;
     data->mem_addr_count = 0;
     data->mem_addrsize = 0;
+    data->mem_addr_last = 0;
     data->mem_addr = 0;
     data->mem_len = 0;
     data->mem_buf = NULL;
@@ -143,24 +153,30 @@ static void machine_i2c_target_data_init(machine_i2c_target_data_t *data, mp_obj
 }
 
 static void machine_i2c_target_data_reset_helper(machine_i2c_target_data_t *data) {
-    size_t len = 0; // TODO
     if (data->state == STATE_READING) {
-        event(data, I2C_TARGET_IRQ_READ_END, data->mem_addr, len);
-    } else if (data->state == STATE_WRITING) {
-        event(data, I2C_TARGET_IRQ_WRITE_END, data->mem_addr, len);
+        handle_event(data, I2C_TARGET_IRQ_END_READ);
+    } else if (data->state == STATE_ADDR_MATCH_WRITE || data->state == STATE_WRITING) {
+        handle_event(data, I2C_TARGET_IRQ_END_WRITE);
     }
     data->state = STATE_IDLE;
 }
 
 static void machine_i2c_target_data_addr_match(machine_i2c_target_data_t *data, bool read) {
-    event(data, I2C_TARGET_IRQ_ADDR_MATCH, read, 0);
     machine_i2c_target_data_reset_helper(data);
+    if (read) {
+        handle_event(data, I2C_TARGET_IRQ_ADDR_MATCH_READ);
+        data->state = STATE_ADDR_MATCH_READ;
+    } else {
+        handle_event(data, I2C_TARGET_IRQ_ADDR_MATCH_WRITE);
+        data->state = STATE_ADDR_MATCH_WRITE;
+    }
 }
 
 static void machine_i2c_target_data_read_request(machine_i2c_target_obj_t *self, machine_i2c_target_data_t *data) {
     // Let the user handle the read request.
-    bool event_handled = event(data, I2C_TARGET_IRQ_READ_REQ, 0, 0);
+    bool event_handled = handle_event(data, I2C_TARGET_IRQ_READ_REQ);
     if (data->mem_buf == NULL) {
+        data->state = STATE_READING;
         if (!event_handled) {
             // No data source, just write out a zero.
             uint8_t val = 0;
@@ -171,11 +187,11 @@ static void machine_i2c_target_data_read_request(machine_i2c_target_obj_t *self,
         if (data->state == STATE_MEM_ADDR_SELECT) {
             // Got a short memory address.
             data->mem_addr %= data->mem_len;
-            event(data, I2C_TARGET_IRQ_MEM_ADDR_MATCH, data->mem_addr, 0);
+            handle_event(data, I2C_TARGET_IRQ_MEM_ADDR_MATCH);
         }
         if (data->state != STATE_READING) {
             data->state = STATE_READING;
-            event(data, I2C_TARGET_IRQ_READ_START, data->mem_addr, 0);
+            handle_event(data, I2C_TARGET_IRQ_READ_START);
         }
         uint8_t val = data->mem_buf[data->mem_addr++];
         if (data->mem_addr >= data->mem_len) {
@@ -187,21 +203,21 @@ static void machine_i2c_target_data_read_request(machine_i2c_target_obj_t *self,
 
 static void machine_i2c_target_data_write_request(machine_i2c_target_obj_t *self, machine_i2c_target_data_t *data) {
     // Let the user handle the write request.
-    bool event_handled = event(data, I2C_TARGET_IRQ_WRITE_REQ, 0, 0);
+    bool event_handled = handle_event(data, I2C_TARGET_IRQ_WRITE_REQ);
     if (data->mem_buf == NULL) {
+        data->state = STATE_WRITING;
         if (!event_handled) {
             // No data sink, just read and discard the incoming byte.
             uint8_t buf = 0;
             mp_machine_i2c_target_read_bytes(self, 1, &buf);
         }
     } else {
         // Have a buffer.
-        // TODO test read-write behaviour
         uint8_t buf[4] = {0};
         size_t n = mp_machine_i2c_target_read_bytes(self, sizeof(buf), &buf[0]);
         for (size_t i = 0; i < n; ++i) {
             uint8_t val = buf[i];
-            if (data->state == STATE_IDLE) {
+            if (data->state == STATE_ADDR_MATCH_WRITE) {
                 data->state = STATE_MEM_ADDR_SELECT;
                 data->mem_addr = 0;
                 data->mem_addr_count = data->mem_addrsize;
@@ -211,12 +227,12 @@ static void machine_i2c_target_data_write_request(machine_i2c_target_obj_t *self
                 --data->mem_addr_count;
                 if (data->mem_addr_count == 0) {
                     data->mem_addr %= data->mem_len;
-                    event(data, I2C_TARGET_IRQ_MEM_ADDR_MATCH, data->mem_addr, 0);
+                    handle_event(data, I2C_TARGET_IRQ_MEM_ADDR_MATCH);
                 }
             } else {
                 if (data->state == STATE_MEM_ADDR_SELECT) {
                     data->state = STATE_WRITING;
-                    event(data, I2C_TARGET_IRQ_WRITE_START, data->mem_addr, 0);
+                    handle_event(data, I2C_TARGET_IRQ_WRITE_START);
                 }
                 data->mem_buf[data->mem_addr++] = val;
                 if (data->mem_addr >= data->mem_len) {
@@ -229,12 +245,11 @@ static void machine_i2c_target_data_write_request(machine_i2c_target_obj_t *self
 
 static inline void machine_i2c_target_data_restart_or_stop(machine_i2c_target_data_t *data) {
     machine_i2c_target_data_reset_helper(data);
-    event(data, I2C_TARGET_IRQ_END, 0, 0);
 }
 
 static inline void machine_i2c_target_data_stop(machine_i2c_target_data_t *data) {
     machine_i2c_target_data_reset_helper(data);
-    event(data, I2C_TARGET_IRQ_END | I2C_TARGET_IRQ_STOP, 0, 0);
+    handle_event(data, I2C_TARGET_IRQ_STOP);
 }
 
 // The port provides implementations of its bindings in this file.
@@ -266,9 +281,19 @@ static mp_obj_t machine_i2c_target_write(mp_obj_t self_in, mp_obj_t data_in) {
 }
 static MP_DEFINE_CONST_FUN_OBJ_2(machine_i2c_target_write_obj, machine_i2c_target_write);
 
+// I2CTarget.memaddr()
+static mp_obj_t machine_i2c_target_memaddr(mp_obj_t self_in) {
+    machine_i2c_target_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    size_t index = mp_machine_i2c_target_get_index(self);
+    machine_i2c_target_data_t *data = &machine_i2c_target_data[index];
+    return mp_obj_new_int(data->mem_addr_last);
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(machine_i2c_target_memaddr_obj, machine_i2c_target_memaddr);
+
 static machine_i2c_target_irq_obj_t *machine_i2c_target_get_irq(machine_i2c_target_obj_t *self) {
     // Get the IRQ object.
-    machine_i2c_target_irq_obj_t *irq = MP_STATE_PORT(machine_i2c_target_irq_obj[0]);
+    size_t index = mp_machine_i2c_target_get_index(self);
+    machine_i2c_target_irq_obj_t *irq = MP_STATE_PORT(machine_i2c_target_irq_obj[index]);
 
     // Allocate the IRQ object if it doesn't already exist.
     if (irq == NULL) {
@@ -278,17 +303,17 @@ static machine_i2c_target_irq_obj_t *machine_i2c_target_get_irq(machine_i2c_targ
         irq->base.parent = MP_OBJ_FROM_PTR(self);
         irq->base.handler = mp_const_none;
         irq->base.ishard = false;
-        MP_STATE_PORT(machine_i2c_target_irq_obj[0]) = irq;
+        MP_STATE_PORT(machine_i2c_target_irq_obj[index]) = irq;
     }
     return irq;
 }
 
-// I2CTarget.irq(handler=None, trigger=IRQ_FALLING|IRQ_RISING, hard=False)
+// I2CTarget.irq(handler=None, trigger=IRQ_END_READ|IRQ_END_WRITE, hard=False)
 static mp_obj_t machine_i2c_target_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     enum { ARG_handler, ARG_trigger, ARG_hard };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_handler, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
-        { MP_QSTR_trigger, MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_trigger, MP_ARG_INT, {.u_int = I2C_TARGET_IRQ_END_READ | I2C_TARGET_IRQ_END_WRITE} },
         { MP_QSTR_hard, MP_ARG_BOOL, {.u_bool = false} },
     };
     machine_i2c_target_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
@@ -304,9 +329,15 @@ static mp_obj_t machine_i2c_target_irq(size_t n_args, const mp_obj_t *pos_args,
         mp_uint_t trigger = args[ARG_trigger].u_int;
         bool hard = args[ARG_hard].u_bool;
 
-        if (!hard) {
+        #if MICROPY_PY_MACHINE_I2C_TARGET_HARD_IRQ
+        if ((trigger & I2C_TARGET_IRQ_ALL_HARD) && !hard) {
             mp_raise_ValueError(MP_ERROR_TEXT("hard IRQ required"));
         }
+        #else
+        if (hard) {
+            mp_raise_ValueError(MP_ERROR_TEXT("hard IRQ unsupported"));
+        }
+        #endif
 
         // Disable all IRQs while data is updated.
         mp_machine_i2c_target_irq_config(self, 0);
@@ -330,13 +361,17 @@ static const mp_rom_map_elem_t machine_i2c_target_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&machine_i2c_target_deinit_obj) },
     { MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&machine_i2c_target_readinto_obj) },
     { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&machine_i2c_target_write_obj) },
+    { MP_ROM_QSTR(MP_QSTR_memaddr), MP_ROM_PTR(&machine_i2c_target_memaddr_obj) },
     { MP_ROM_QSTR(MP_QSTR_irq), MP_ROM_PTR(&machine_i2c_target_irq_obj) },
 
-    { MP_ROM_QSTR(MP_QSTR_IRQ_ADDR_MATCH), MP_ROM_INT(I2C_TARGET_IRQ_ADDR_MATCH) },
+    #if MICROPY_PY_MACHINE_I2C_TARGET_HARD_IRQ
+    { MP_ROM_QSTR(MP_QSTR_IRQ_ADDR_MATCH_READ), MP_ROM_INT(I2C_TARGET_IRQ_ADDR_MATCH_READ) },
+    { MP_ROM_QSTR(MP_QSTR_IRQ_ADDR_MATCH_WRITE), MP_ROM_INT(I2C_TARGET_IRQ_ADDR_MATCH_WRITE) },
     { MP_ROM_QSTR(MP_QSTR_IRQ_READ_REQ), MP_ROM_INT(I2C_TARGET_IRQ_READ_REQ) },
     { MP_ROM_QSTR(MP_QSTR_IRQ_WRITE_REQ), MP_ROM_INT(I2C_TARGET_IRQ_WRITE_REQ) },
-    { MP_ROM_QSTR(MP_QSTR_IRQ_END), MP_ROM_INT(I2C_TARGET_IRQ_END) },
-    { MP_ROM_QSTR(MP_QSTR_IRQ_STOP), MP_ROM_INT(I2C_TARGET_IRQ_STOP) },
+    #endif
+    { MP_ROM_QSTR(MP_QSTR_IRQ_END_READ), MP_ROM_INT(I2C_TARGET_IRQ_END_READ) },
+    { MP_ROM_QSTR(MP_QSTR_IRQ_END_WRITE), MP_ROM_INT(I2C_TARGET_IRQ_END_WRITE) },
 };
 static MP_DEFINE_CONST_DICT(machine_i2c_target_locals_dict, machine_i2c_target_locals_dict_table);
 
@@ -351,7 +386,8 @@ MP_DEFINE_CONST_OBJ_TYPE(
 
 static mp_uint_t machine_i2c_target_irq_trigger(mp_obj_t self_in, mp_uint_t new_trigger) {
     machine_i2c_target_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    machine_i2c_target_irq_obj_t *irq = MP_STATE_PORT(machine_i2c_target_irq_obj[0]);
+    size_t index = mp_machine_i2c_target_get_index(self);
+    machine_i2c_target_irq_obj_t *irq = MP_STATE_PORT(machine_i2c_target_irq_obj[index]);
     mp_machine_i2c_target_irq_config(self, 0);
     irq->flags = 0;
     irq->trigger = new_trigger;
@@ -360,8 +396,9 @@ static mp_uint_t machine_i2c_target_irq_trigger(mp_obj_t self_in, mp_uint_t new_
 }
 
 static mp_uint_t machine_i2c_target_irq_info(mp_obj_t self_in, mp_uint_t info_type) {
-    // machine_i2c_target_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    machine_i2c_target_irq_obj_t *irq = MP_STATE_PORT(machine_i2c_target_irq_obj[0]);
+    machine_i2c_target_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    size_t index = mp_machine_i2c_target_get_index(self);
+    machine_i2c_target_irq_obj_t *irq = MP_STATE_PORT(machine_i2c_target_irq_obj[index]);
     if (info_type == MP_IRQ_INFO_FLAGS) {
         return irq->flags;
     } else if (info_type == MP_IRQ_INFO_TRIGGERS) {