Add BUSIO.I2C and MAX32690 I2C structure

- Data structure and constructor for I2C (tested)
- Lock and probing functions complete and tested

TODO: Implement I2C Write, Read, Wr/Rd

Signed-off-by: Brandon-Hurst <[email protected]>

Author: Brandon-Hurst

ports/analog/Makefile

@@ -86,7 +86,8 @@ INC += \
 	-I$(PERIPH_SRC)/ICC \
 	-I$(PERIPH_SRC)/TMR \
 	-I$(PERIPH_SRC)/RTC \
-	-I$(PERIPH_SRC)/UART
+	-I$(PERIPH_SRC)/UART \
+	-I$(PERIPH_SRC)/I2C
 
 INC += -I$(CMSIS_ROOT)/Device/Maxim/$(MCU_VARIANT_UPPER)/Source/GCC
 
@@ -119,14 +120,18 @@ SRC_MAX32 += \
 	$(PERIPH_SRC)/TMR/tmr_$(DIE_TYPE).c \
 	$(PERIPH_SRC)/UART/uart_common.c \
 	$(PERIPH_SRC)/UART/uart_$(DIE_TYPE).c \
-	$(PERIPH_SRC)/UART/uart_revb.c
+	$(PERIPH_SRC)/UART/uart_revb.c \
+	$(PERIPH_SRC)/I2C/i2c_$(DIE_TYPE).c \
+	$(PERIPH_SRC)/I2C/i2c_reva.c
 
 SRC_C += $(SRC_MAX32) \
 			boards/$(BOARD)/board.c \
 			boards/$(BOARD)/pins.c \
 			peripherals/$(MCU_VARIANT_LOWER)/pins.c \
 			peripherals/$(MCU_VARIANT_LOWER)/gpios.c \
-			peripherals/$(MCU_VARIANT_LOWER)/max32_uart.c
+			peripherals/$(MCU_VARIANT_LOWER)/max32_uart.c \
+			peripherals/$(MCU_VARIANT_LOWER)/max32_i2c.c
+
 
 # *******************************************************************************
 ### Compiler & Linker Flags ###
@@ -267,6 +272,11 @@ flash-msdk:
 		-f interface/cmsis-dap.cfg -f target/$(MCU_VARIANT_LOWER).cfg \
 		-c "program $(BUILD)/firmware.elf verify; init; reset; exit"
 
+flash-openocd-jlink:
+	$(OPENOCD) -s $(OPENOCD_SCRIPTS) \
+		-f interface/jlink.cfg -f target/$(MCU_VARIANT_LOWER).cfg \
+		-c "program $(BUILD)/firmware.elf verify; init; reset; exit"
+
 # flash target using JLink
 JLINK_DEVICE = $(MCU_VARIANT_LOWER)
 

ports/analog/common-hal/busio/I2C.c

@@ -30,15 +30,103 @@
 #include "shared-bindings/microcontroller/__init__.h"
 #include "shared-bindings/microcontroller/Pin.h"
 
-static bool in_used = false;
+#include "max32_port.h"
+
+#define I2C_PRIORITY 1
+
+typedef enum {
+    I2C_FREE = 0,
+    I2C_BUSY,
+    I2C_NEVER_RESET,
+} i2c_status_t;
+
+// Set each bit to indicate an active UART
+// will be checked by ISR Handler for which ones to call
+static uint8_t i2c_active = 0;
+static i2c_status_t i2c_status[NUM_I2C];
+static volatile int i2c_err;
+
+// I2C Interrupt Handler
+void i2c_isr(void) {
+    for (int i = 0; i < NUM_I2C; i++) {
+        if (i2c_active & (1 << i)) {
+            // NOTE: I2C_GET_TMR actually returns the I2C registers
+            MXC_I2C_AsyncHandler(MXC_I2C_GET_I2C(i));
+        }
+    }
+}
+
+// Callback gets called when AsyncRequest is COMPLETE
+// (e.g. txLen == txCnt)
+// static volatile void i2cCallback(mxc_i2c_req_t *req, int error) {
+//     i2c_status[MXC_I2C_GET_IDX(req->i2c)] = I2C_FREE;
+//     i2c_err = error;
+// }
 
 // Construct I2C protocol, this function init i2c peripheral
 void common_hal_busio_i2c_construct(busio_i2c_obj_t *self,
     const mcu_pin_obj_t *scl,
     const mcu_pin_obj_t *sda,
     uint32_t frequency, uint32_t timeout) {
 
-
+    int temp, err = 0;
+
+    // Check for NULL Pointers && valid I2C settings
+    assert(self);
+
+    // Assign I2C ID based on pins
+    temp = pinsToI2c(sda, scl);
+    if (temp == -1) {
+        // Error will be indicated by pinsToUart(tx, rx) function
+        return;
+    } else {
+        self->i2c_id = temp;
+        self->i2c_regs = MXC_I2C_GET_I2C(temp);
+    }
+
+    assert((self->i2c_id >= 0) && (self->i2c_id < NUM_I2C));
+
+    // Init I2C as main / controller node (0x00 is ignored)
+    if ((scl != NULL) && (sda != NULL)) {
+        err = MXC_I2C_Init(self->i2c_regs, 1, 0x00);
+        if (err) {
+            mp_raise_RuntimeError(MP_ERROR_TEXT("Failed to init I2C.\n"));
+        }
+        err = MXC_I2C_SetFrequency(self->i2c_regs, frequency);
+        if (err < 0) {
+            mp_raise_RuntimeError(MP_ERROR_TEXT("Failed to set I2C frequency\n"));
+        }
+    } else if (scl != NULL) {
+        mp_raise_NotImplementedError(MP_ERROR_TEXT("I2C needs SDA & SCL"));
+    } else if (sda != NULL) {
+        mp_raise_NotImplementedError(MP_ERROR_TEXT("I2C needs SDA & SCL"));
+    } else {
+        // Should not get here, as shared-bindings API should not call this way
+    }
+
+    // Attach I2C pins
+    self->sda = sda;
+    self->scl = scl;
+    common_hal_mcu_pin_claim(self->sda);
+    common_hal_mcu_pin_claim(self->scl);
+
+    // Indicate to this module that the I2C is active
+    i2c_active |= (1 << self->i2c_id);
+
+    // Set the timeout to a default value
+    if (((timeout < 0.0) || (timeout > 100.0))) {
+        self->timeout = 1.0;
+    } else {
+        self->timeout = timeout;
+    }
+
+    /* Setup I2C interrupt */
+    NVIC_ClearPendingIRQ(MXC_I2C_GET_IRQ(self->i2c_id));
+    NVIC_DisableIRQ(MXC_I2C_GET_IRQ(self->i2c_id));
+    NVIC_SetPriority(MXC_I2C_GET_IRQ(self->i2c_id), I2C_PRIORITY);
+    NVIC_SetVector(MXC_I2C_GET_IRQ(self->i2c_id), (uint32_t)i2c_isr);
+
+    return;
 }
 
 // Never reset I2C obj when reload
@@ -54,7 +142,13 @@ bool common_hal_busio_i2c_deinited(busio_i2c_obj_t *self) {
 
 // Deinit i2c obj, reset I2C pin
 void common_hal_busio_i2c_deinit(busio_i2c_obj_t *self) {
-    // FIXME: Implement
+    MXC_I2C_Shutdown(self->i2c_regs);
+
+    common_hal_reset_pin(self->sda);
+    common_hal_reset_pin(self->scl);
+
+    self->sda = NULL;
+    self->scl = NULL;
 }
 
 void common_hal_busio_i2c_mark_deinit(busio_i2c_obj_t *self) {
@@ -63,17 +157,36 @@ void common_hal_busio_i2c_mark_deinit(busio_i2c_obj_t *self) {
 
 // Probe device in I2C bus
 bool common_hal_busio_i2c_probe(busio_i2c_obj_t *self, uint8_t addr) {
-    // FIXME: Implement
-
-    return true;
+    int nack = 0;
+
+    mxc_i2c_req_t addr_req = {
+        .addr = addr,
+        .i2c = self->i2c_regs,
+        .tx_len = 0,
+        .tx_buf = NULL,
+        .rx_len = 0,
+        .rx_buf = NULL,
+        .callback = NULL
+    };
+
+    // Probe the address
+    nack = MXC_I2C_MasterTransaction(&addr_req);
+    if (nack) {
+        return false;
+    } else {
+        return true;
+    }
 }
 
 // Lock I2C bus
 bool common_hal_busio_i2c_try_lock(busio_i2c_obj_t *self) {
 
-    // FIXME: Implement
-
-    return false;
+    if (self->i2c_regs->status & MXC_F_I2C_STATUS_BUSY) {
+        return false;
+    } else {
+        self->has_lock = true;
+        return true;
+    }
 }
 
 // Check I2C lock status

ports/analog/common-hal/busio/I2C.h

@@ -17,8 +17,13 @@
 // Define a struct for what BUSIO.I2C should carry
 typedef struct {
     mp_obj_base_t base;
+
+    int i2c_id;
     mxc_i2c_regs_t *i2c_regs;
-    bool has_lock;
     const mcu_pin_obj_t *scl;
     const mcu_pin_obj_t *sda;
+    const int frequency;
+
+    uint32_t timeout;
+    bool has_lock;
 } busio_i2c_obj_t;

ports/analog/max32_port.h

@@ -24,7 +24,7 @@
 
 // UART Ports & pins
 #include "peripherals/max32690/max32_uart.h"
-#define NUM_UARTS 4
+#include "peripherals/max32690/max32_i2c.h"
 
 /** START: GPIO4 Handling specific to MAX32690 */
     #define GPIO4_PIN_MASK 0x00000003

ports/analog/peripherals/max32690/max32_i2c.c

@@ -0,0 +1,35 @@
+// This file is part of the CircuitPython project: https://circuitpython.org
+//
+// SPDX-FileCopyrightText: Copyright (c) 2024 Brandon Hurst, Analog Devices, Inc.
+//
+// SPDX-License-Identifier: MIT
+
+#include "peripherals/pins.h"
+
+#include "common-hal/busio/I2C.h"
+#include "max32_i2c.h"
+#include "max32690.h"
+
+#include "py/runtime.h"
+#include "py/mperrno.h"
+
+const mxc_gpio_cfg_t i2c_maps[NUM_I2C] = {
+    // I2C0A
+    { MXC_GPIO0, (MXC_GPIO_PIN_30 | MXC_GPIO_PIN_31), MXC_GPIO_FUNC_ALT1,
+      MXC_GPIO_PAD_NONE, MXC_GPIO_VSSEL_VDDIO, MXC_GPIO_DRVSTR_0 },
+    // I2C1A
+    { MXC_GPIO2, (MXC_GPIO_PIN_17 | MXC_GPIO_PIN_18), MXC_GPIO_FUNC_ALT1,
+      MXC_GPIO_PAD_NONE, MXC_GPIO_VSSEL_VDDIO, MXC_GPIO_DRVSTR_0 },
+};
+
+int pinsToI2c(const mcu_pin_obj_t *sda, const mcu_pin_obj_t *scl) {
+    for (int i = 0; i < NUM_I2C; i++) {
+        if ((i2c_maps[i].port == (MXC_GPIO_GET_GPIO(sda->port)))
+            && (i2c_maps[i].mask == ((sda->mask) | (scl->mask)))) {
+            return i;
+        }
+    }
+    mp_raise_RuntimeError_varg(MP_ERROR_TEXT("ERR: Unable to find an I2C matching pins...\nSCL: port %d mask %d\nSDA: port %d mask %d\n"),
+        sda->port, sda->mask, scl->port, scl->mask);
+    return -1;
+}

ports/analog/peripherals/max32690/max32_i2c.h

@@ -0,0 +1,16 @@
+// This file is part of the CircuitPython project: https://circuitpython.org
+//
+// SPDX-FileCopyrightText: Copyright (c) 2024 Brandon Hurst, Analog Devices, Inc.
+//
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include "i2c_regs.h"
+#include "mxc_sys.h"
+#include "i2c.h"
+#include "peripherals/pins.h"
+
+#define NUM_I2C 2
+
+int pinsToI2c(const mcu_pin_obj_t *sda, const mcu_pin_obj_t *scl);