pbio/drv/i2c/i2c_ev3.c: Implement I2C operation

This implements performing an I2C operation asynchronously.
It does not hook this up to any higher-level functionality.

Author: ArcaneNibble

lib/pbio/drv/i2c/i2c_ev3.c

@@ -100,9 +100,75 @@ static void pbdrv_i2c_irq_3(void) {
     pbio_os_request_poll();
 }
 
-pbio_error_t pbdrv_i2c_placeholder_operation(pbdrv_i2c_dev_t *i2c_dev, const char *operation) {
-    debug_pr("I2C placeholder operation %s\n", operation);
-    return PBIO_SUCCESS;
+pbio_error_t pbdrv_i2c_write_then_read(
+    pbio_os_state_t *state,
+    pbdrv_i2c_dev_t *i2c_dev,
+    uint8_t dev_addr,
+    const uint8_t *wdata,
+    size_t wlen,
+    uint8_t *rdata,
+    size_t rlen,
+    bool nxt_quirk) {
+
+    PBIO_OS_ASYNC_BEGIN(state);
+
+    if (wlen && !wdata) {
+        return PBIO_ERROR_INVALID_ARG;
+    }
+    if (rlen && !rdata) {
+        return PBIO_ERROR_INVALID_ARG;
+    }
+    if (wlen > 0xff || rlen > 0xff) {
+        return PBIO_ERROR_INVALID_ARG;
+    }
+
+    if (i2c_dev->is_busy) {
+        return PBIO_ERROR_BUSY;
+    }
+
+    // Prepare TX data
+    if (wlen) {
+        memcpy(i2c_dev->buffer, wdata, wlen);
+    }
+    i2c_dev->is_busy = true;
+    pbdrv_cache_prepare_before_dma(i2c_dev->buffer, PRU_I2C_MAX_BYTES_PER_TXN);
+
+    // Kick off transfer
+    pbdrv_rproc_ev3_pru1_shared_ram.i2c[i2c_dev->pru_i2c_idx].flags = PBDRV_RPROC_EV3_PRU1_I2C_PACK_FLAGS(
+        dev_addr,
+        rlen,
+        wlen,
+        PBDRV_RPROC_EV3_PRU1_I2C_CMD_START | (nxt_quirk ? PBDRV_RPROC_EV3_PRU1_I2C_CMD_NXT_QUIRK : 0)
+        );
+
+    // Wait for transfer to finish
+    PBIO_OS_AWAIT_WHILE(state, i2c_dev->is_busy);
+
+    uint32_t flags = pbdrv_rproc_ev3_pru1_shared_ram.i2c[i2c_dev->pru_i2c_idx].flags;
+    debug_pr("i2c %d done flags %08x\r\n", i2c_dev->pru_i2c_idx, flags);
+    if (!(flags & PBDRV_RPROC_EV3_PRU1_I2C_STAT_DONE)) {
+        debug_pr("i2c %d not actually done???\r\n", i2c_dev->pru_i2c_idx);
+        return PBIO_ERROR_FAILED;
+    }
+    switch (flags & PBDRV_RPROC_EV3_PRU1_I2C_STAT_MASK) {
+        case PBDRV_RPROC_EV3_PRU1_I2C_STAT_OK:
+            break;
+        case PBDRV_RPROC_EV3_PRU1_I2C_STAT_TIMEOUT:
+            return PBIO_ERROR_TIMEDOUT;
+        case PBDRV_RPROC_EV3_PRU1_I2C_STAT_NAK:
+            return PBIO_ERROR_IO;
+        default:
+            debug_pr("i2c %d unknown error occurred???\r\n", i2c_dev->pru_i2c_idx);
+            return PBIO_ERROR_FAILED;
+    }
+
+    // If we got here, there's no error. Copy RX data.
+    pbdrv_cache_prepare_after_dma(i2c_dev->buffer, PRU_I2C_MAX_BYTES_PER_TXN);
+    if (rlen) {
+        memcpy(rdata, &i2c_dev->buffer[wlen], rlen);
+    }
+
+    PBIO_OS_ASYNC_END(PBIO_SUCCESS);
 }
 
 static pbio_os_process_t ev3_i2c_init_process;

lib/pbio/include/pbdrv/i2c.h

@@ -13,6 +13,7 @@
 
 #include <pbdrv/config.h>
 #include <pbio/error.h>
+#include <pbio/os.h>
 #include <pbio/port.h>
 #include <contiki.h>
 
@@ -30,16 +31,37 @@ typedef struct _pbdrv_i2c_dev_t pbdrv_i2c_dev_t;
 pbio_error_t pbdrv_i2c_get_instance(uint8_t id, pbdrv_i2c_dev_t **i2c_dev);
 
 /**
- * Does an I2C operation. To be replaced.
+ * Does an I2C operation. To be integrated with higher-level code.
  *
- * Doesn't do anything yet. This is a placeholder so someone knowledgable with
- * EV3 I2C has a starting point without setting up all the boilerplate.
- *
- * @param [in]  i2c_dev    The I2C device.
- * @param [in]  operation  Dummy parameter.
- * @return                 ::PBIO_SUCCESS on success.
+ * @param [in]  state       Protothread state for async operation.
+ * @param [in]  i2c_dev     The I2C device.
+ * @param [in]  dev_addr    I2C device address (unshifted).
+ * @param [in]  wdata       Data to be sent to the device.
+ *                          Can be null if \p wlen is 0.
+ * @param [in]  wlen        Length of \p wdata.
+ *                          If this is 0 and \p rlen is also 0,
+ *                          an empty "ping" will be sent, consisting of
+ *                          only a device address (with R/nW = 0).
+ *                          If this is 0 but \p rlen is not 0,
+ *                          a read transaction will be sent.
+ *                          If this is not 0 and \p rlen is not 0,
+ *                          a write will be sent followed by a read in
+ *                          a single transaction.
+ * @param [out] rdata       Buffer for data read from the device.
+ *                          Can be null if \p rlen is 0.
+ * @param [in]  rlen        Size of \p rdata.
+ * @param [in]  nxt_quirk   Whether to use NXT I2C transaction quirk.
+ * @return                  ::PBIO_SUCCESS on success.
  */
-pbio_error_t pbdrv_i2c_placeholder_operation(pbdrv_i2c_dev_t *i2c_dev, const char *operation);
+pbio_error_t pbdrv_i2c_write_then_read(
+    pbio_os_state_t *state,
+    pbdrv_i2c_dev_t *i2c_dev,
+    uint8_t dev_addr,
+    const uint8_t *wdata,
+    size_t wlen,
+    uint8_t *rdata,
+    size_t rlen,
+    bool nxt_quirk);
 
 // Delete above and add read/write functions here. See I2C driver for examples, also protothreads.
 
@@ -50,7 +72,15 @@ static inline pbio_error_t pbdrv_i2c_get_instance(uint8_t id, pbdrv_i2c_dev_t **
     return PBIO_ERROR_NOT_SUPPORTED;
 }
 
-static inline pbio_error_t pbdrv_i2c_placeholder_operation(pbdrv_i2c_dev_t *i2c_dev, const char *operation) {
+static inline pbio_error_t pbdrv_i2c_write_then_read(
+    pbio_os_state_t *state,
+    pbdrv_i2c_dev_t *i2c_dev,
+    uint8_t dev_addr,
+    const uint8_t *wdata,
+    size_t wlen,
+    uint8_t *rdata,
+    size_t rlen,
+    bool nxt_quirk) {
     return PBIO_ERROR_NOT_SUPPORTED;
 }